fix Typographical errors

Machometec · Machometec · commit a90f9edbba91 · 2023-11-25T12:08:19.000-05:00
diff --git a/lib/Async/CancellationSource.php b/lib/Async/CancellationSource.php
@@ -15,15 +15,15 @@ class CancellationSource
 {
     use PropertyTrait;
 
-    private CancelationToken $token;
+    private CancellationToken $token;
     private bool $isCancellationRequested = false;
 
     public function __construct()
     {
-        $this->token = new CancelationToken($this);
+        $this->token = new CancellationToken($this);
     }
 
-    public function get_Token(): CancelationToken
+    public function get_Token(): CancellationToken
     {
         return $this->token;
     }
diff --git a/lib/Collections/AbstractArray.php b/lib/Collections/AbstractArray.php
@@ -90,7 +90,7 @@ public function offsetGet($key): mixed
     }
 
     /**
-     * Unsets the value with the specified key from the array.
+     * Unset the value with the specified key from the array.
      */
     public function offsetUnset($key): void
     {
diff --git a/lib/Command/Help/HelpBuilder.php b/lib/Command/Help/HelpBuilder.php
@@ -56,9 +56,9 @@ public function writeRows(array $rows): void
         ksort($rows);
         foreach ($rows as $label => $description) {
             $lines[$this->indent . $label] = $description;
-            $lenth = strlen($label);
-            if ($lenth > $this->maxWidth) {
-                $this->maxWidth = $lenth;
+            $length = strlen($label);
+            if ($length > $this->maxWidth) {
+                $this->maxWidth = $length;
             }
         }
 
@@ -109,8 +109,8 @@ public function writeUsage(): void
             $usage .= '[options]';
         }
 
-        $this->writeline($usage);
-        $this->writeline();
+        $this->writeLine($usage);
+        $this->writeLine();
     }
 
     public function writeArguments(): void
@@ -122,7 +122,7 @@ public function writeArguments(): void
                 $rows[$argument->Name] = $argument->Description;
             }
             $this->writeRows($rows);
-            $this->writeline();
+            $this->writeLine();
         }
     }
 
@@ -139,7 +139,7 @@ public function writeOptions(): void
                 $rows[$name] = $option->Description;
             }
             $this->writeRows($rows);
-            $this->writeline();
+            $this->writeLine();
         }
     }
 
@@ -152,7 +152,7 @@ public function writeCommands(): void
                 $rows[$command->Name] = $command->Description;
             }
             $this->writeRows($rows);
-            $this->writeline();
+            $this->writeLine();
         }
     }
 
diff --git a/lib/Command/Help/HelpResult.php b/lib/Command/Help/HelpResult.php
@@ -42,8 +42,8 @@ public function write(): void
                         if ($this->secondaryColor) {
                             Console::$ForegroundColor = $this->secondaryColor;
                         }
-                        $lenth = strlen($name);
-                        $space = str_repeat(" ", $this->maxWidth - $lenth + 4);
+                        $length = strlen($name);
+                        $space = str_repeat(" ", $this->maxWidth - $length + 4);
                         Console::write($name . $space);
                         Console::resetColor();
                         Console::writeLine($description);
diff --git a/lib/Compiler/ExpressionParser.php b/lib/Compiler/ExpressionParser.php
@@ -186,7 +186,7 @@ public function getBody(): ?Expression
                         $variableName  = ltrim($items[2]->getValue(), '$');
 
                         if (!array_key_exists($variableName, $this->outerVariables)) {
-                            throw new ParserException("Undefined property variable \${$parameterName}::${$variableName}");
+                            throw new ParserException("Undefined property variable \${$parameterName}::\${$variableName}");
                         }
 
                         if (!is_string($this->outerVariables[$variableName])) {
diff --git a/lib/Compiler/Expressions/ExpressionType.php b/lib/Compiler/Expressions/ExpressionType.php
@@ -11,8 +11,8 @@
 
 class ExpressionType
 {
-    const Constant = 'DevNet\System\Linq\Expressions\ConstantExpression';
-    const Parameter = 'DevNet\System\Linq\Expressions\ParameterExpression';
-    const Property = 'DevNet\System\Linq\Expressions\PropertyExpression';
-    const Binary = 'DevNet\System\Linq\Expressions\BinaryExpression';
+    const Constant  = ConstantExpression::class;
+    const Parameter = ParameterExpression::class;
+    const Property  = PropertyExpression::class;
+    const Binary    = BinaryExpression::class;
 }
diff --git a/lib/Compiler/Lexing/LexerBuilder.php b/lib/Compiler/Lexing/LexerBuilder.php
@@ -15,13 +15,13 @@ class LexerBuilder
 
     public function define(string $name, string $pattern): void
     {
-        $this->definitions[] = new TokenDefenition($name, $pattern);
+        $this->definitions[] = new TokenDefinition($name, $pattern);
     }
 
     public function build(): Lexer
     {
-        $this->definitions[] = new TokenDefenition(Token::SKIPPED, "\s+");
-        $this->definitions[] = new TokenDefenition(Token::UNKNOWN, "[^\s]+");
+        $this->definitions[] = new TokenDefinition(Token::SKIPPED, "\s+");
+        $this->definitions[] = new TokenDefinition(Token::UNKNOWN, "[^\s]+");
         return new Lexer($this->definitions);
     }
 }
diff --git a/lib/Compiler/Lexing/TokenDefinition.php b/lib/Compiler/Lexing/TokenDefinition.php
@@ -9,7 +9,7 @@
 
 namespace DevNet\System\Compiler\Lexing;
 
-class TokenDefenition
+class TokenDefinition
 {
     public string $Name;
     public string $Pattern;
diff --git a/lib/Compiler/Parsing/Grammar.php b/lib/Compiler/Parsing/Grammar.php
@@ -42,8 +42,8 @@ public function match($state, int $position, string $itemName): array
         $this->state = $state;
         $matchedRules = [];
         foreach ($state as $rule) {
-            if (isset($rule->Predecates[$position])) {
-                if ($rule->Predecates[$position] == $itemName) {
+            if (isset($rule->Predicates[$position])) {
+                if ($rule->Predicates[$position] == $itemName) {
                     $matchedRules[$rule->Index] = $rule;
                 }
             }
@@ -56,8 +56,8 @@ public function lookAhead(string $item): array
     {
         $nextRules = [];
         foreach ($this->rules as $rule) {
-            if (isset($rule->Predecates[0])) {
-                if ($rule->Predecates[0] == $item && count($rule->Predecates) > 1) {
+            if (isset($rule->Predicates[0])) {
+                if ($rule->Predicates[0] == $item && count($rule->Predicates) > 1) {
                     $nextRules[$rule->Index] = $rule;
                 }
             }
diff --git a/lib/Dependency/ServiceDescriptor.php b/lib/Dependency/ServiceDescriptor.php
@@ -26,9 +26,9 @@ class ServiceDescriptor
 
     private int $lifetime;
     private string $serviceType;
-    private ?string $implimentationType = null;
+    private ?string $implementationType = null;
     private ?object $implementationInstance = null;
-    private ?Closure $implimentationFactory = null;
+    private ?Closure $implementationFactory = null;
 
     public function __construct(int $lifetime, string $serviceType, $service = null)
     {
@@ -50,7 +50,7 @@ public function __construct(int $lifetime, string $serviceType, $service = null)
                 if (!$serviceType->isAssignableFrom(new Type($service))) {
                     throw new TypeException("The registered service is not compatible with the declared type {$serviceType}", 0, 1);
                 }
-                $this->implimentationType = $service;
+                $this->implementationType = $service;
                 break;
             case is_object($service):
                 if ($service instanceof Closure) {
@@ -59,14 +59,14 @@ public function __construct(int $lifetime, string $serviceType, $service = null)
                         throw new TypeException("The service factory must have a return type", 0, 1);
                     }
 
-                    // The registered service must be assignable to the factory returne type and to the declared service type
-                    // and the declared service type must be assignable to and from the factory returne type
-                    // becasue both can be concrete or abstract type of the registed service.
+                    // The registered service must be assignable to the factory retune type and to the declared service type
+                    // and the declared service type must be assignable to and from the factory return type
+                    // because both can be concrete or abstract type of the registered service.
                     $type = new Type($reflector->getReturnType()->getName());
                     if (!$serviceType->isAssignableFrom($type) && !$serviceType->isAssignableTo($type)) {
                         throw new TypeException("The registered service is not compatible with the declared type {$serviceType}", 0, 1);
                     }
-                    $this->implimentationFactory = $service;
+                    $this->implementationFactory = $service;
                 } else {
                     // The registered service must be assignable to the declared service type
                     if (!$serviceType->isTypeOf($service)) {
@@ -91,18 +91,18 @@ public function get_ServiceType(): string
         return $this->serviceType;
     }
 
-    public function get_ImplimentationType(): ?string
+    public function get_ImplementationType(): ?string
     {
-        return $this->implimentationType;
+        return $this->implementationType;
     }
 
     public function get_ImplementationInstance(): ?object
     {
         return $this->implementationInstance;
     }
 
-    public function get_ImplimentationFactory(): ?Closure
+    public function get_ImplementationFactory(): ?Closure
     {
-        return $this->implimentationFactory;
+        return $this->implementationFactory;
     }
 }
diff --git a/lib/Dependency/ServiceProvider.php b/lib/Dependency/ServiceProvider.php
@@ -12,7 +12,7 @@
 class ServiceProvider implements IServiceProvider
 {
     private array $instanceServices = [];
-    private IserviceCollection $serviceCollection;
+    private IServiceCollection $serviceCollection;
 
     public function __construct(IServiceCollection $serviceCollection)
     {
@@ -40,7 +40,7 @@ public function getService(string $serviceType): ?object
                     return $serviceDescriptor->ImplementationInstance;
                 }
 
-                if ($serviceDescriptor->ImplimentationType) {
+                if ($serviceDescriptor->ImplementationType) {
                     if (isset($this->instanceServices[$serviceType])) {
                         if ($serviceDescriptor->Lifetime == 1) {
                             return $this->instanceServices[$serviceType];
@@ -51,12 +51,12 @@ public function getService(string $serviceType): ?object
                         }
                     }
 
-                    $instance = Activator::CreateInstance($serviceDescriptor->ImplimentationType, $this);
+                    $instance = Activator::CreateInstance($serviceDescriptor->ImplementationType, $this);
                     $this->instanceServices[$serviceType] = $instance;
                     return $instance;
                 }
 
-                if ($serviceDescriptor->ImplimentationFactory) {
+                if ($serviceDescriptor->ImplementationFactory) {
                     if (isset($this->instanceServices[$serviceType])) {
                         if ($serviceDescriptor->Lifetime == 1) {
                             return $this->instanceServices[$serviceType];
@@ -66,7 +66,7 @@ public function getService(string $serviceType): ?object
                             return clone $this->instanceServices[$serviceType];
                         }
                     }
-                    $factory = $serviceDescriptor->ImplimentationFactory;
+                    $factory = $serviceDescriptor->ImplementationFactory;
                     $instance = $factory($this);
 
                     $this->instanceServices[$serviceType] = $instance;
diff --git a/lib/Linq.php b/lib/Linq.php
@@ -17,39 +17,39 @@
 
 class Linq
 {
-    public static function select(IEnumerable $enumerable, Closure $predecate): IEnumerable
+    public static function select(IEnumerable $enumerable, Closure $predicate): IEnumerable
     {
-        return Enumerable::select($enumerable, $predecate);
+        return Enumerable::select($enumerable, $predicate);
     }
 
-    public static function where(IEnumerable $enumerable, Closure $predecate): IEnumerable
+    public static function where(IEnumerable $enumerable, Closure $predicate): IEnumerable
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            return Queryable::where($enumerable, $predecate);
+            return Queryable::where($enumerable, $predicate);
         }
 
-        return Enumerable::where($enumerable, $predecate);
+        return Enumerable::where($enumerable, $predicate);
     }
 
-    public static function orderBy(IEnumerable $enumerable, Closure $predecate): IEnumerable
+    public static function orderBy(IEnumerable $enumerable, Closure $predicate): IEnumerable
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            return Queryable::orderBy($enumerable, $predecate);
+            return Queryable::orderBy($enumerable, $predicate);
         }
 
-        return Enumerable::orderBy($enumerable, $predecate);
+        return Enumerable::orderBy($enumerable, $predicate);
     }
 
-    public static function orderByDescending(IEnumerable $enumerable, Closure $predecate): IEnumerable
+    public static function orderByDescending(IEnumerable $enumerable, Closure $predicate): IEnumerable
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            return Queryable::orderByDescending($enumerable, $predecate);
+            return Queryable::orderByDescending($enumerable, $predicate);
         }
 
-        return Enumerable::orderByDescending($enumerable, $predecate);
+        return Enumerable::orderByDescending($enumerable, $predicate);
     }
 
     public static function skip(IEnumerable $enumerable, int $offset): IEnumerable
@@ -72,54 +72,54 @@ public static function take(IEnumerable $enumerable, int $limit): IEnumerable
         return Enumerable::take($enumerable, $limit);
     }
 
-    public static function groupBy(IEnumerable $enumerable, Closure $predecate): IEnumerable
+    public static function groupBy(IEnumerable $enumerable, Closure $predicate): IEnumerable
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            throw new \Exception("Queriable method not implemented yet, try it as Enumerable");
+            throw new \Exception("Queryable method not implemented yet, try it as Enumerable");
         }
 
-        return Enumerable::groupBy($enumerable, $predecate);
+        return Enumerable::groupBy($enumerable, $predicate);
     }
 
     public static function join(IEnumerable $enumerable, $innerCollection, Closure $outerSelector, Closure $innerSelector, Closure $resultSelector): IEnumerable
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            throw new \Exception("Queriable method not implemented yet, try it as Enumerable");
+            throw new \Exception("Queryable method not implemented yet, try it as Enumerable");
         }
 
         return Enumerable::join($enumerable, $innerCollection, $outerSelector, $innerSelector, $resultSelector);
     }
 
-    public static function count(IEnumerable $enumerable, Closure $predecate = null): int
+    public static function count(IEnumerable $enumerable, Closure $predicate = null): int
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            throw new \Exception("Queriable method not implemented yet, try it as Enumerable");
+            throw new \Exception("Queryable method not implemented yet, try it as Enumerable");
         }
 
-        return Enumerable::count($enumerable, $predecate);
+        return Enumerable::count($enumerable, $predicate);
     }
 
-    public static function max(IEnumerable $enumerable, Closure $predecate = null)
+    public static function max(IEnumerable $enumerable, Closure $predicate = null)
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            throw new \Exception("Queriable method not implemented yet, try it as Enumerable");
+            throw new \Exception("Queryable method not implemented yet, try it as Enumerable");
         }
 
-        return Enumerable::max($enumerable, $predecate);
+        return Enumerable::max($enumerable, $predicate);
     }
 
-    public static function min(IEnumerable $enumerable, Closure $predecate = null)
+    public static function min(IEnumerable $enumerable, Closure $predicate = null)
     {
         $interfaces = class_implements($enumerable);
         if (in_array(IQueryable::class, $interfaces)) {
-            throw new \Exception("Queriable method not implemented yet, try it as Enumerable");
+            throw new \Exception("Queryable method not implemented yet, try it as Enumerable");
         }
 
-        return Enumerable::min($enumerable, $predecate);
+        return Enumerable::min($enumerable, $predicate);
     }
 
     public static function first(IEnumerable $enumerable)
diff --git a/lib/Linq/Enumerable.php b/lib/Linq/Enumerable.php
diff --git a/lib/Linq/IQueryProvider.php b/lib/Linq/IQueryProvider.php
diff --git a/lib/Linq/IQueryable.php b/lib/Linq/IQueryable.php
diff --git a/lib/Text/Regex.php b/lib/Text/Regex.php

Original file line number	Diff line number	Diff line change
`@@ -15,15 +15,15 @@ class CancellationSource`
`15`	`15`	`{`
`16`	`16`	`use PropertyTrait;`
`17`	`17`
`18`		`- private CancelationToken $token;`
	`18`	`+ private CancellationToken $token;`
`19`	`19`	`private bool $isCancellationRequested = false;`
`20`	`20`
`21`	`21`	`public function __construct()`
`22`	`22`	`{`
`23`		`- $this->token = new CancelationToken($this);`
	`23`	`+ $this->token = new CancellationToken($this);`
`24`	`24`	`}`
`25`	`25`
`26`		`- public function get_Token(): CancelationToken`
	`26`	`+ public function get_Token(): CancellationToken`
`27`	`27`	`{`
`28`	`28`	`return $this->token;`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ public function offsetGet($key): mixed`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`/**`
`93`		`- * Unsets the value with the specified key from the array.`
	`93`	`+ * Unset the value with the specified key from the array.`
`94`	`94`	`*/`
`95`	`95`	`public function offsetUnset($key): void`
`96`	`96`	`{`
Original file line number	Diff line number	Diff line change
`@@ -56,9 +56,9 @@ public function writeRows(array $rows): void`
`56`	`56`	`ksort($rows);`
`57`	`57`	`foreach ($rows as $label => $description) {`
`58`	`58`	`$lines[$this->indent . $label] = $description;`
`59`		`- $lenth = strlen($label);`
`60`		`- if ($lenth > $this->maxWidth) {`
`61`		`- $this->maxWidth = $lenth;`
	`59`	`+ $length = strlen($label);`
	`60`	`+ if ($length > $this->maxWidth) {`
	`61`	`+ $this->maxWidth = $length;`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`@@ -109,8 +109,8 @@ public function writeUsage(): void`
`109`	`109`	`$usage .= '[options]';`
`110`	`110`	`}`
`111`	`111`
`112`		`- $this->writeline($usage);`
`113`		`- $this->writeline();`
	`112`	`+ $this->writeLine($usage);`
	`113`	`+ $this->writeLine();`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`public function writeArguments(): void`
`@@ -122,7 +122,7 @@ public function writeArguments(): void`
`122`	`122`	`$rows[$argument->Name] = $argument->Description;`
`123`	`123`	`}`
`124`	`124`	`$this->writeRows($rows);`
`125`		`- $this->writeline();`
	`125`	`+ $this->writeLine();`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`@@ -139,7 +139,7 @@ public function writeOptions(): void`
`139`	`139`	`$rows[$name] = $option->Description;`
`140`	`140`	`}`
`141`	`141`	`$this->writeRows($rows);`
`142`		`- $this->writeline();`
	`142`	`+ $this->writeLine();`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`
`@@ -152,7 +152,7 @@ public function writeCommands(): void`
`152`	`152`	`$rows[$command->Name] = $command->Description;`
`153`	`153`	`}`
`154`	`154`	`$this->writeRows($rows);`
`155`		`- $this->writeline();`
	`155`	`+ $this->writeLine();`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`
Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ public function getBody(): ?Expression`
`186`	`186`	`$variableName = ltrim($items[2]->getValue(), '$');`
`187`	`187`
`188`	`188`	`if (!array_key_exists($variableName, $this->outerVariables)) {`
`189`		`- throw new ParserException("Undefined property variable \${$parameterName}::${$variableName}");`
	`189`	`+ throw new ParserException("Undefined property variable \${$parameterName}::\${$variableName}");`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`if (!is_string($this->outerVariables[$variableName])) {`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,8 @@`
`11`	`11`
`12`	`12`	`class ExpressionType`
`13`	`13`	`{`
`14`		`- const Constant = 'DevNet\System\Linq\Expressions\ConstantExpression';`
`15`		`- const Parameter = 'DevNet\System\Linq\Expressions\ParameterExpression';`
`16`		`- const Property = 'DevNet\System\Linq\Expressions\PropertyExpression';`
`17`		`- const Binary = 'DevNet\System\Linq\Expressions\BinaryExpression';`
	`14`	`+ const Constant = ConstantExpression::class;`
	`15`	`+ const Parameter = ParameterExpression::class;`
	`16`	`+ const Property = PropertyExpression::class;`
	`17`	`+ const Binary = BinaryExpression::class;`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,13 @@ class LexerBuilder`
`15`	`15`
`16`	`16`	`public function define(string $name, string $pattern): void`
`17`	`17`	`{`
`18`		`- $this->definitions[] = new TokenDefenition($name, $pattern);`
	`18`	`+ $this->definitions[] = new TokenDefinition($name, $pattern);`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public function build(): Lexer`
`22`	`22`	`{`
`23`		`- $this->definitions[] = new TokenDefenition(Token::SKIPPED, "\s+");`
`24`		`- $this->definitions[] = new TokenDefenition(Token::UNKNOWN, "[^\s]+");`
	`23`	`+ $this->definitions[] = new TokenDefinition(Token::SKIPPED, "\s+");`
	`24`	`+ $this->definitions[] = new TokenDefinition(Token::UNKNOWN, "[^\s]+");`
`25`	`25`	`return new Lexer($this->definitions);`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`namespace DevNet\System\Compiler\Lexing;`
`11`	`11`
`12`		`-class TokenDefenition`
	`12`	`+class TokenDefinition`
`13`	`13`	`{`
`14`	`14`	`public string $Name;`
`15`	`15`	`public string $Pattern;`
Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ public function match($state, int $position, string $itemName): array`
`42`	`42`	`$this->state = $state;`
`43`	`43`	`$matchedRules = [];`
`44`	`44`	`foreach ($state as $rule) {`
`45`		`- if (isset($rule->Predecates[$position])) {`
`46`		`- if ($rule->Predecates[$position] == $itemName) {`
	`45`	`+ if (isset($rule->Predicates[$position])) {`
	`46`	`+ if ($rule->Predicates[$position] == $itemName) {`
`47`	`47`	`$matchedRules[$rule->Index] = $rule;`
`48`	`48`	`}`
`49`	`49`	`}`
`@@ -56,8 +56,8 @@ public function lookAhead(string $item): array`
`56`	`56`	`{`
`57`	`57`	`$nextRules = [];`
`58`	`58`	`foreach ($this->rules as $rule) {`
`59`		`- if (isset($rule->Predecates[0])) {`
`60`		`- if ($rule->Predecates[0] == $item && count($rule->Predecates) > 1) {`
	`59`	`+ if (isset($rule->Predicates[0])) {`
	`60`	`+ if ($rule->Predicates[0] == $item && count($rule->Predicates) > 1) {`
`61`	`61`	`$nextRules[$rule->Index] = $rule;`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ class ServiceDescriptor`
`26`	`26`
`27`	`27`	`private int $lifetime;`
`28`	`28`	`private string $serviceType;`
`29`		`- private ?string $implimentationType = null;`
	`29`	`+ private ?string $implementationType = null;`
`30`	`30`	`private ?object $implementationInstance = null;`
`31`		`- private ?Closure $implimentationFactory = null;`
	`31`	`+ private ?Closure $implementationFactory = null;`
`32`	`32`
`33`	`33`	`public function __construct(int $lifetime, string $serviceType, $service = null)`
`34`	`34`	`{`
`@@ -50,7 +50,7 @@ public function __construct(int $lifetime, string $serviceType, $service = null)`
`50`	`50`	`if (!$serviceType->isAssignableFrom(new Type($service))) {`
`51`	`51`	`throw new TypeException("The registered service is not compatible with the declared type {$serviceType}", 0, 1);`
`52`	`52`	`}`
`53`		`- $this->implimentationType = $service;`
	`53`	`+ $this->implementationType = $service;`
`54`	`54`	`break;`
`55`	`55`	`case is_object($service):`
`56`	`56`	`if ($service instanceof Closure) {`
`@@ -59,14 +59,14 @@ public function __construct(int $lifetime, string $serviceType, $service = null)`
`59`	`59`	`throw new TypeException("The service factory must have a return type", 0, 1);`
`60`	`60`	`}`
`61`	`61`
`62`		`- // The registered service must be assignable to the factory returne type and to the declared service type`
`63`		`- // and the declared service type must be assignable to and from the factory returne type`
`64`		`- // becasue both can be concrete or abstract type of the registed service.`
	`62`	`+ // The registered service must be assignable to the factory retune type and to the declared service type`
	`63`	`+ // and the declared service type must be assignable to and from the factory return type`
	`64`	`+ // because both can be concrete or abstract type of the registered service.`
`65`	`65`	`$type = new Type($reflector->getReturnType()->getName());`
`66`	`66`	`if (!$serviceType->isAssignableFrom($type) && !$serviceType->isAssignableTo($type)) {`
`67`	`67`	`throw new TypeException("The registered service is not compatible with the declared type {$serviceType}", 0, 1);`
`68`	`68`	`}`
`69`		`- $this->implimentationFactory = $service;`
	`69`	`+ $this->implementationFactory = $service;`
`70`	`70`	`} else {`
`71`	`71`	`// The registered service must be assignable to the declared service type`
`72`	`72`	`if (!$serviceType->isTypeOf($service)) {`
`@@ -91,18 +91,18 @@ public function get_ServiceType(): string`
`91`	`91`	`return $this->serviceType;`
`92`	`92`	`}`
`93`	`93`
`94`		`- public function get_ImplimentationType(): ?string`
	`94`	`+ public function get_ImplementationType(): ?string`
`95`	`95`	`{`
`96`		`- return $this->implimentationType;`
	`96`	`+ return $this->implementationType;`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`public function get_ImplementationInstance(): ?object`
`100`	`100`	`{`
`101`	`101`	`return $this->implementationInstance;`
`102`	`102`	`}`
`103`	`103`
`104`		`- public function get_ImplimentationFactory(): ?Closure`
	`104`	`+ public function get_ImplementationFactory(): ?Closure`
`105`	`105`	`{`
`106`		`- return $this->implimentationFactory;`
	`106`	`+ return $this->implementationFactory;`
`107`	`107`	`}`
`108`	`108`	`}`