Original naming

langsamu · langsamu · commit b4118f25ce78 · 2026-02-14T11:54:07.000Z
diff --git a/README.md b/README.md
@@ -50,11 +50,11 @@ import { TermWrapper, ValueMapping, TermMapping } from "https://unpkg.com/rdfjs-
 
 class Person extends TermWrapper {
 	get name() {
-		return this.getSingularNullable("https://example.org/name", ValueMapping.literalToString)
+		return this.singularNullable("https://example.org/name", ValueMapping.literalToString)
 	}
 
 	set name(value) {
-		this.setSingularNullable("https://example.org/name", value, TermMapping.literalToString)
+		this.overwriteNullable("https://example.org/name", value, TermMapping.literalToString)
 	}
 }
 ```
@@ -129,19 +129,19 @@ import { TermWrapper, ValueMapping, TermMapping, ObjectMapping } from "https://u
 
 class Person extends TermWrapper {
 	get name() {
-		return this.getSingularNullable("https://example.org/name", ValueMapping.literalToString)
+		return this.singularNullable("https://example.org/name", ValueMapping.literalToString)
 	}
 
 	set name(value) {
-		this.getSingularNullable("https://example.org/name", value, TermMapping.literalToString)
+		this.singularNullable("https://example.org/name", value, TermMapping.literalToString)
 	}
 
 	get mum() {
-		return this.getSingularNullable("https://example.org/mum", ObjectMapping.as(Person))
+		return this.singularNullable("https://example.org/mum", ObjectMapping.as(Person))
 	}
 
 	set mum(value) {
-		this.setSingularNullable("https://example.org/mum", value, ObjectMapping.as(Person))
+		this.overwriteNullable("https://example.org/mum", value, ObjectMapping.as(Person))
 	}
 }
 ```
diff --git a/src/TermWrapper.ts b/src/TermWrapper.ts
@@ -21,7 +21,7 @@ export class TermWrapper {
         this.factory = factory;
     }
 
-    protected getSingular<T>(p: string, valueMapping: IValueMapping<T>): T {
+    protected singular<T>(p: string, valueMapping: IValueMapping<T>): T {
         const predicate = this.factory.namedNode(p)
         const matches = this.dataset.match(this.term, predicate)
 
@@ -37,7 +37,7 @@ export class TermWrapper {
         throw new Error(`No value found for predicate ${p} on term ${this.term.value}`)
     }
 
-    protected getSingularNullable<T>(p: string, valueMapping: IValueMapping<T>): T | undefined {
+    protected singularNullable<T>(p: string, valueMapping: IValueMapping<T>): T | undefined {
         const predicate = this.factory.namedNode(p)
 
         for (const q of this.dataset.match(this.term, predicate)) {
@@ -47,15 +47,15 @@ export class TermWrapper {
         return
     }
 
-    protected setSingular<T>(p: string, value: T, nodeMapping: ITermMapping<T>): void {
+    protected overwrite<T>(p: string, value: T, nodeMapping: ITermMapping<T>): void {
         if (value === undefined) {
             throw new Error("value cannot be undefined")
         }
 
-        this.setSingularNullable(p, value, nodeMapping)
+        this.overwriteNullable(p, value, nodeMapping)
     }
 
-    protected setSingularNullable<T>(p: string, value: T | undefined, termMapping: ITermMapping<T>): void {
+    protected overwriteNullable<T>(p: string, value: T | undefined, termMapping: ITermMapping<T>): void {
         const predicate = this.factory.namedNode(p)
 
         for (const q of this.dataset.match(this.term, predicate)) {
@@ -88,7 +88,7 @@ export class TermWrapper {
         this.dataset.add(q)
     }
 
-    protected getSet<T>(p: string, valueMapping: IValueMapping<T>, termMapping: ITermMapping<T>): Set<T> {
+    protected objects<T>(p: string, valueMapping: IValueMapping<T>, termMapping: ITermMapping<T>): Set<T> {
         return new WrappingSet(this, p, valueMapping, termMapping)
     }
 
diff --git a/src/decorators/getter.ts b/src/decorators/getter.ts
@@ -11,11 +11,11 @@ export function getter(predicate: string, getterArity: GetterArity, valueMapping
         return function (this: TermWrapper): any {
             switch (getterArity) {
                 case GetterArity.Singular:
-                    return this.getSingular(predicate, valueMapping)
+                    return this.singular(predicate, valueMapping)
                 case GetterArity.SingularNullable:
-                    return this.getSingularNullable(predicate, valueMapping)
+                    return this.singularNullable(predicate, valueMapping)
                 case GetterArity.Set:
-                    return this.getSet(predicate, valueMapping, termMapping)
+                    return this.objects(predicate, valueMapping, termMapping)
             }
         }
     }
diff --git a/src/decorators/setter.ts b/src/decorators/setter.ts
@@ -9,10 +9,10 @@ export function setter(predicate: string, setterArity: SetterArity, termMapping:
         return function (this: TermWrapper, value: any): void {
             switch (setterArity) {
                 case SetterArity.Singular:
-                    this.setSingular(predicate, value, termMapping)
+                    this.overwrite(predicate, value, termMapping)
                     break
                 case SetterArity.SingularNullable:
-                    this.setSingularNullable(predicate, value, termMapping)
+                    this.overwriteNullable(predicate, value, termMapping)
                     break
             }
         }
diff --git a/test/unit/model/Child.ts b/test/unit/model/Child.ts
@@ -3,10 +3,10 @@ import { Example } from "../vocabulary/Example.js"
 
 export class Child extends TermWrapper {
     public get hasString(): string | undefined {
-        return this.getSingularNullable(Example.hasString, ValueMapping.literalToString)
+        return this.singularNullable(Example.hasString, ValueMapping.literalToString)
     }
 
     public set hasString(value: string | undefined) {
-        this.setSingularNullable(Example.hasString, value, TermMapping.stringToLiteral)
+        this.overwriteNullable(Example.hasString, value, TermMapping.stringToLiteral)
     }
 }
diff --git a/test/unit/model/Parent.ts b/test/unit/model/Parent.ts
@@ -7,100 +7,100 @@ import { Example } from "../vocabulary/Example.js"
 export class Parent extends TermWrapper {
     /* Value Mapping */
     public get hasBlankNode(): string {
-        return this.getSingular(Example.hasBlankNode, ValueMapping.blankNodeToString)
+        return this.singular(Example.hasBlankNode, ValueMapping.blankNodeToString)
     }
 
     public get hasDate(): Date {
-        return this.getSingular(Example.hasDate, ValueMapping.literalToDate)
+        return this.singular(Example.hasDate, ValueMapping.literalToDate)
     }
 
     public get hasLangString(): ILangString {
-        return this.getSingular(Example.hasLangString, ValueMapping.literalToLangString)
+        return this.singular(Example.hasLangString, ValueMapping.literalToLangString)
     }
 
     public get hasNumber(): number {
-        return this.getSingular(Example.hasNumber, ValueMapping.literalToNumber)
+        return this.singular(Example.hasNumber, ValueMapping.literalToNumber)
     }
 
     public get hasString(): string {
-        return this.getSingular(Example.hasString, ValueMapping.literalToString)
+        return this.singular(Example.hasString, ValueMapping.literalToString)
     }
 
     public get hasIri(): string {
-        return this.getSingular(Example.hasIri, ValueMapping.iriToString)
+        return this.singular(Example.hasIri, ValueMapping.iriToString)
     }
 
 
     /* Term Mapping */
     public set hasBlankNode(value: string) {
-        this.setSingular(Example.hasBlankNode, value, TermMapping.stringToBlankNode)
+        this.overwrite(Example.hasBlankNode, value, TermMapping.stringToBlankNode)
     }
 
     public set hasDate(value: Date ) {
-        this.setSingular(Example.hasDate, value, TermMapping.dateToLiteral)
+        this.overwrite(Example.hasDate, value, TermMapping.dateToLiteral)
     }
 
     public set hasLangString(value: ILangString ) {
-        this.setSingular(Example.hasLangString, value, TermMapping.langStringToLiteral)
+        this.overwrite(Example.hasLangString, value, TermMapping.langStringToLiteral)
     }
 
     public set hasNumber(value: number ) {
-        this.setSingular(Example.hasNumber, value, TermMapping.numberToLiteral)
+        this.overwrite(Example.hasNumber, value, TermMapping.numberToLiteral)
     }
 
     public set hasString(value: string ) {
-        this.setSingular(Example.hasString, value, TermMapping.stringToLiteral)
+        this.overwrite(Example.hasString, value, TermMapping.stringToLiteral)
     }
 
     public set hasIri(value: string ) {
-        this.setSingular(Example.hasIri, value, TermMapping.stringToIri)
+        this.overwrite(Example.hasIri, value, TermMapping.stringToIri)
     }
 
 
     /* Object Mapping */
     public get hasChild(): Child {
-        return this.getSingular(Example.hasChild, ObjectMapping.as(Child))
+        return this.singular(Example.hasChild, ObjectMapping.as(Child))
     }
 
     public set hasChild(value: Child) {
-        this.setSingularNullable(Example.hasChild, value, ObjectMapping.as(Child))
+        this.overwriteNullable(Example.hasChild, value, ObjectMapping.as(Child))
     }
 
 
     /* Arity Mapping */
     public get hasNoSingularString(): string {
-        return this.getSingular(Example.hasNoSingularString, ValueMapping.literalToString)
+        return this.singular(Example.hasNoSingularString, ValueMapping.literalToString)
     }
 
     public get hasTooManySingularString(): string {
-        return this.getSingular(Example.hasTooManySingularString, ValueMapping.literalToString)
+        return this.singular(Example.hasTooManySingularString, ValueMapping.literalToString)
     }
 
     public get hasNullableString(): string | undefined {
-        return this.getSingularNullable(Example.hasNullableString, ValueMapping.literalToString)
+        return this.singularNullable(Example.hasNullableString, ValueMapping.literalToString)
     }
 
     public set hasNullableString(value: string | undefined ) {
-        this.setSingularNullable(Example.hasNullableString, value, TermMapping.stringToLiteral)
+        this.overwriteNullable(Example.hasNullableString, value, TermMapping.stringToLiteral)
     }
 
 
     /* Set Mapping */
     public get hasChildSet(): Set<Child> {
-        return this.getSet(Example.hasChildSet, ObjectMapping.as(Child), ObjectMapping.as(Child))
+        return this.objects(Example.hasChildSet, ObjectMapping.as(Child), ObjectMapping.as(Child))
     }
 
     public get hasLangStringSet(): Set<ILangString> {
-        return this.getSet(Example.hasLangStringSet, ValueMapping.literalToLangString, TermMapping.langStringToLiteral)
+        return this.objects(Example.hasLangStringSet, ValueMapping.literalToLangString, TermMapping.langStringToLiteral)
     }
 
 
     /* Recursion Mapping */
     public get hasRecursive(): Parent {
-        return this.getSingular(Example.hasRecursive, ObjectMapping.as(Parent))
+        return this.singular(Example.hasRecursive, ObjectMapping.as(Parent))
     }
 
     public set hasRecursive(value: string | undefined) {
-        this.setSingularNullable(Example.hasRecursive, value, TermMapping.stringToIri)
+        this.overwriteNullable(Example.hasRecursive, value, TermMapping.stringToIri)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -50,11 +50,11 @@ import { TermWrapper, ValueMapping, TermMapping } from "https://unpkg.com/rdfjs-`
`50`	`50`
`51`	`51`	`class Person extends TermWrapper {`
`52`	`52`	`get name() {`
`53`		`- return this.getSingularNullable("https://example.org/name", ValueMapping.literalToString)`
	`53`	`+ return this.singularNullable("https://example.org/name", ValueMapping.literalToString)`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`set name(value) {`
`57`		`- this.setSingularNullable("https://example.org/name", value, TermMapping.literalToString)`
	`57`	`+ this.overwriteNullable("https://example.org/name", value, TermMapping.literalToString)`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	```
`@@ -129,19 +129,19 @@ import { TermWrapper, ValueMapping, TermMapping, ObjectMapping } from "https://u`
`129`	`129`
`130`	`130`	`class Person extends TermWrapper {`
`131`	`131`	`get name() {`
`132`		`- return this.getSingularNullable("https://example.org/name", ValueMapping.literalToString)`
	`132`	`+ return this.singularNullable("https://example.org/name", ValueMapping.literalToString)`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`set name(value) {`
`136`		`- this.getSingularNullable("https://example.org/name", value, TermMapping.literalToString)`
	`136`	`+ this.singularNullable("https://example.org/name", value, TermMapping.literalToString)`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`get mum() {`
`140`		`- return this.getSingularNullable("https://example.org/mum", ObjectMapping.as(Person))`
	`140`	`+ return this.singularNullable("https://example.org/mum", ObjectMapping.as(Person))`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`set mum(value) {`
`144`		`- this.setSingularNullable("https://example.org/mum", value, ObjectMapping.as(Person))`
	`144`	`+ this.overwriteNullable("https://example.org/mum", value, ObjectMapping.as(Person))`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	```
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ export class TermWrapper {`
`21`	`21`	`this.factory = factory;`
`22`	`22`	`}`
`23`	`23`
`24`		`- protected getSingular<T>(p: string, valueMapping: IValueMapping<T>): T {`
	`24`	`+ protected singular<T>(p: string, valueMapping: IValueMapping<T>): T {`
`25`	`25`	`const predicate = this.factory.namedNode(p)`
`26`	`26`	`const matches = this.dataset.match(this.term, predicate)`
`27`	`27`
`@@ -37,7 +37,7 @@ export class TermWrapper {`
`37`	`37`	throw new Error(`No value found for predicate ${p} on term ${this.term.value}`)
`38`	`38`	`}`
`39`	`39`
`40`		`- protected getSingularNullable<T>(p: string, valueMapping: IValueMapping<T>): T \| undefined {`
	`40`	`+ protected singularNullable<T>(p: string, valueMapping: IValueMapping<T>): T \| undefined {`
`41`	`41`	`const predicate = this.factory.namedNode(p)`
`42`	`42`
`43`	`43`	`for (const q of this.dataset.match(this.term, predicate)) {`
`@@ -47,15 +47,15 @@ export class TermWrapper {`
`47`	`47`	`return`
`48`	`48`	`}`
`49`	`49`
`50`		`- protected setSingular<T>(p: string, value: T, nodeMapping: ITermMapping<T>): void {`
	`50`	`+ protected overwrite<T>(p: string, value: T, nodeMapping: ITermMapping<T>): void {`
`51`	`51`	`if (value === undefined) {`
`52`	`52`	`throw new Error("value cannot be undefined")`
`53`	`53`	`}`
`54`	`54`
`55`		`- this.setSingularNullable(p, value, nodeMapping)`
	`55`	`+ this.overwriteNullable(p, value, nodeMapping)`
`56`	`56`	`}`
`57`	`57`
`58`		`- protected setSingularNullable<T>(p: string, value: T \| undefined, termMapping: ITermMapping<T>): void {`
	`58`	`+ protected overwriteNullable<T>(p: string, value: T \| undefined, termMapping: ITermMapping<T>): void {`
`59`	`59`	`const predicate = this.factory.namedNode(p)`
`60`	`60`
`61`	`61`	`for (const q of this.dataset.match(this.term, predicate)) {`
`@@ -88,7 +88,7 @@ export class TermWrapper {`
`88`	`88`	`this.dataset.add(q)`
`89`	`89`	`}`
`90`	`90`
`91`		`- protected getSet<T>(p: string, valueMapping: IValueMapping<T>, termMapping: ITermMapping<T>): Set<T> {`
	`91`	`+ protected objects<T>(p: string, valueMapping: IValueMapping<T>, termMapping: ITermMapping<T>): Set<T> {`
`92`	`92`	`return new WrappingSet(this, p, valueMapping, termMapping)`
`93`	`93`	`}`
`94`	`94`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,11 @@ export function getter(predicate: string, getterArity: GetterArity, valueMapping`
`11`	`11`	`return function (this: TermWrapper): any {`
`12`	`12`	`switch (getterArity) {`
`13`	`13`	`case GetterArity.Singular:`
`14`		`- return this.getSingular(predicate, valueMapping)`
	`14`	`+ return this.singular(predicate, valueMapping)`
`15`	`15`	`case GetterArity.SingularNullable:`
`16`		`- return this.getSingularNullable(predicate, valueMapping)`
	`16`	`+ return this.singularNullable(predicate, valueMapping)`
`17`	`17`	`case GetterArity.Set:`
`18`		`- return this.getSet(predicate, valueMapping, termMapping)`
	`18`	`+ return this.objects(predicate, valueMapping, termMapping)`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,10 +9,10 @@ export function setter(predicate: string, setterArity: SetterArity, termMapping:`
`9`	`9`	`return function (this: TermWrapper, value: any): void {`
`10`	`10`	`switch (setterArity) {`
`11`	`11`	`case SetterArity.Singular:`
`12`		`- this.setSingular(predicate, value, termMapping)`
	`12`	`+ this.overwrite(predicate, value, termMapping)`
`13`	`13`	`break`
`14`	`14`	`case SetterArity.SingularNullable:`
`15`		`- this.setSingularNullable(predicate, value, termMapping)`
	`15`	`+ this.overwriteNullable(predicate, value, termMapping)`
`16`	`16`	`break`
`17`	`17`	`}`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,10 +3,10 @@ import { Example } from "../vocabulary/Example.js"`
`3`	`3`
`4`	`4`	`export class Child extends TermWrapper {`
`5`	`5`	`public get hasString(): string \| undefined {`
`6`		`- return this.getSingularNullable(Example.hasString, ValueMapping.literalToString)`
	`6`	`+ return this.singularNullable(Example.hasString, ValueMapping.literalToString)`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`public set hasString(value: string \| undefined) {`
`10`		`- this.setSingularNullable(Example.hasString, value, TermMapping.stringToLiteral)`
	`10`	`+ this.overwriteNullable(Example.hasString, value, TermMapping.stringToLiteral)`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,100 +7,100 @@ import { Example } from "../vocabulary/Example.js"`
`7`	`7`	`export class Parent extends TermWrapper {`
`8`	`8`	`/* Value Mapping */`
`9`	`9`	`public get hasBlankNode(): string {`
`10`		`- return this.getSingular(Example.hasBlankNode, ValueMapping.blankNodeToString)`
	`10`	`+ return this.singular(Example.hasBlankNode, ValueMapping.blankNodeToString)`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`public get hasDate(): Date {`
`14`		`- return this.getSingular(Example.hasDate, ValueMapping.literalToDate)`
	`14`	`+ return this.singular(Example.hasDate, ValueMapping.literalToDate)`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public get hasLangString(): ILangString {`
`18`		`- return this.getSingular(Example.hasLangString, ValueMapping.literalToLangString)`
	`18`	`+ return this.singular(Example.hasLangString, ValueMapping.literalToLangString)`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public get hasNumber(): number {`
`22`		`- return this.getSingular(Example.hasNumber, ValueMapping.literalToNumber)`
	`22`	`+ return this.singular(Example.hasNumber, ValueMapping.literalToNumber)`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public get hasString(): string {`
`26`		`- return this.getSingular(Example.hasString, ValueMapping.literalToString)`
	`26`	`+ return this.singular(Example.hasString, ValueMapping.literalToString)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public get hasIri(): string {`
`30`		`- return this.getSingular(Example.hasIri, ValueMapping.iriToString)`
	`30`	`+ return this.singular(Example.hasIri, ValueMapping.iriToString)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`
`34`	`34`	`/* Term Mapping */`
`35`	`35`	`public set hasBlankNode(value: string) {`
`36`		`- this.setSingular(Example.hasBlankNode, value, TermMapping.stringToBlankNode)`
	`36`	`+ this.overwrite(Example.hasBlankNode, value, TermMapping.stringToBlankNode)`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public set hasDate(value: Date ) {`
`40`		`- this.setSingular(Example.hasDate, value, TermMapping.dateToLiteral)`
	`40`	`+ this.overwrite(Example.hasDate, value, TermMapping.dateToLiteral)`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public set hasLangString(value: ILangString ) {`
`44`		`- this.setSingular(Example.hasLangString, value, TermMapping.langStringToLiteral)`
	`44`	`+ this.overwrite(Example.hasLangString, value, TermMapping.langStringToLiteral)`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public set hasNumber(value: number ) {`
`48`		`- this.setSingular(Example.hasNumber, value, TermMapping.numberToLiteral)`
	`48`	`+ this.overwrite(Example.hasNumber, value, TermMapping.numberToLiteral)`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`public set hasString(value: string ) {`
`52`		`- this.setSingular(Example.hasString, value, TermMapping.stringToLiteral)`
	`52`	`+ this.overwrite(Example.hasString, value, TermMapping.stringToLiteral)`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`public set hasIri(value: string ) {`
`56`		`- this.setSingular(Example.hasIri, value, TermMapping.stringToIri)`
	`56`	`+ this.overwrite(Example.hasIri, value, TermMapping.stringToIri)`
`57`	`57`	`}`
`58`	`58`
`59`	`59`
`60`	`60`	`/* Object Mapping */`
`61`	`61`	`public get hasChild(): Child {`
`62`		`- return this.getSingular(Example.hasChild, ObjectMapping.as(Child))`
	`62`	`+ return this.singular(Example.hasChild, ObjectMapping.as(Child))`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`public set hasChild(value: Child) {`
`66`		`- this.setSingularNullable(Example.hasChild, value, ObjectMapping.as(Child))`
	`66`	`+ this.overwriteNullable(Example.hasChild, value, ObjectMapping.as(Child))`
`67`	`67`	`}`
`68`	`68`
`69`	`69`
`70`	`70`	`/* Arity Mapping */`
`71`	`71`	`public get hasNoSingularString(): string {`
`72`		`- return this.getSingular(Example.hasNoSingularString, ValueMapping.literalToString)`
	`72`	`+ return this.singular(Example.hasNoSingularString, ValueMapping.literalToString)`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`public get hasTooManySingularString(): string {`
`76`		`- return this.getSingular(Example.hasTooManySingularString, ValueMapping.literalToString)`
	`76`	`+ return this.singular(Example.hasTooManySingularString, ValueMapping.literalToString)`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public get hasNullableString(): string \| undefined {`
`80`		`- return this.getSingularNullable(Example.hasNullableString, ValueMapping.literalToString)`
	`80`	`+ return this.singularNullable(Example.hasNullableString, ValueMapping.literalToString)`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`public set hasNullableString(value: string \| undefined ) {`
`84`		`- this.setSingularNullable(Example.hasNullableString, value, TermMapping.stringToLiteral)`
	`84`	`+ this.overwriteNullable(Example.hasNullableString, value, TermMapping.stringToLiteral)`
`85`	`85`	`}`
`86`	`86`
`87`	`87`
`88`	`88`	`/* Set Mapping */`
`89`	`89`	`public get hasChildSet(): Set<Child> {`
`90`		`- return this.getSet(Example.hasChildSet, ObjectMapping.as(Child), ObjectMapping.as(Child))`
	`90`	`+ return this.objects(Example.hasChildSet, ObjectMapping.as(Child), ObjectMapping.as(Child))`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`public get hasLangStringSet(): Set<ILangString> {`
`94`		`- return this.getSet(Example.hasLangStringSet, ValueMapping.literalToLangString, TermMapping.langStringToLiteral)`
	`94`	`+ return this.objects(Example.hasLangStringSet, ValueMapping.literalToLangString, TermMapping.langStringToLiteral)`
`95`	`95`	`}`
`96`	`96`
`97`	`97`
`98`	`98`	`/* Recursion Mapping */`
`99`	`99`	`public get hasRecursive(): Parent {`
`100`		`- return this.getSingular(Example.hasRecursive, ObjectMapping.as(Parent))`
	`100`	`+ return this.singular(Example.hasRecursive, ObjectMapping.as(Parent))`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`public set hasRecursive(value: string \| undefined) {`
`104`		`- this.setSingularNullable(Example.hasRecursive, value, TermMapping.stringToIri)`
	`104`	`+ this.overwriteNullable(Example.hasRecursive, value, TermMapping.stringToIri)`
`105`	`105`	`}`
`106`	`106`	`}`