├── .gitignore ├── Copyright.txt ├── Examples ├── Abstract │ ├── AbstractKeyword.kt │ ├── Implementations.kt │ ├── InterfaceCollision.kt │ ├── MultipleInterfaceInheritance.kt │ ├── NoMultipleInheritance.kt │ ├── NoStateInInterfaces.kt │ ├── PropertyAccessor.kt │ ├── Redundant.kt │ ├── StateOfAClass.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── AtomicTest │ └── AtomicTest.kt ├── BaseClassInit │ ├── GreatApe3.kt │ ├── House.kt │ ├── NoArgConstructor.kt │ ├── OtherConstructors.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── Booleans │ ├── Closed.kt │ ├── EvaluationOrder.kt │ ├── Foo.kt │ ├── Open1.kt │ ├── Open2.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── BreakAndContinue │ ├── DoWhileControl.kt │ ├── ForControl.kt │ ├── ForLabeled.kt │ ├── Improved.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── WhileControl.kt │ └── WhileLabeled.kt ├── BuildingMaps │ ├── AssociateBy.kt │ ├── AssociateByUnique.kt │ ├── AssociateWith.kt │ ├── FilterMap.kt │ ├── GetOrPut.kt │ ├── GroupBy.kt │ ├── GroupByVsFilter.kt │ ├── People.kt │ ├── SimilarOperation.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── TransformingMap.kt ├── CheckInstructions │ ├── CheckInstructionsSoln1.kt │ ├── CheckInstructionsSoln2.kt │ ├── CheckInstructionsSoln3.kt │ ├── CheckInstructionsSoln4.kt │ ├── DataFile.kt │ ├── GetTrace.kt │ ├── JulianMonth.kt │ ├── Postconditions.kt │ ├── QuadraticRequire.kt │ ├── RequireNotNull.kt │ └── SingleArgRequire.kt ├── ClassDelegation │ ├── BasicDelegation.kt │ ├── DelegatedControls.kt │ ├── ExplicitDelegation.kt │ ├── ModelingMI.kt │ ├── SpaceShipControls.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── CompanionObjects │ ├── CompanionDelegation.kt │ ├── CompanionEx1.kt │ ├── CompanionEx2.kt │ ├── CompanionEx3.kt │ ├── CompanionFactory.kt │ ├── CompanionInstance.kt │ ├── CompanionObject.kt │ ├── DelegateAndExtend.kt │ ├── Initialization.kt │ ├── NamingCompanionObjects.kt │ ├── ObjectCounter.kt │ ├── ObjectFunctions.kt │ └── ObjectProperty.kt ├── ComplexConstructors │ ├── Exercise1.kt │ ├── Exercise2.kt │ ├── Exercise3.kt │ ├── InitSection.kt │ └── SimpleConstructor.kt ├── Composition │ ├── Car.kt │ ├── Embedding.kt │ ├── House1.kt │ ├── House2.kt │ ├── House3.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── Constructors │ ├── Arg.kt │ ├── DisplayAlienSpecies.kt │ ├── MultipleArgs.kt │ ├── Scientist.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── VisibleArgs.kt │ └── Wombat.kt ├── CreatingClasses │ ├── Animals.kt │ ├── Cat.kt │ ├── Dog.kt │ ├── Hamster.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── Task5.kt ├── CreatingGenerics │ ├── BoxAssignment.kt │ ├── CarCrate.kt │ ├── CheckType.kt │ ├── Constrained.kt │ ├── Constraints.kt │ ├── CovariantList.kt │ ├── CovariantReturnTypes.kt │ ├── Crate.kt │ ├── CreatingGenericsSoln1.kt │ ├── CreatingGenericsSoln2.kt │ ├── CreatingGenericsSoln3.kt │ ├── DefiningGenerics.kt │ ├── Disposable.kt │ ├── Erasure.kt │ ├── InAndOutBoxes.kt │ ├── InBoxAssignment.kt │ ├── MapCrate.kt │ ├── NonGenericConstraint.kt │ ├── OutBoxAssignment.kt │ ├── Pets.kt │ ├── ReificationA.kt │ ├── ReificationB.kt │ ├── ReificationC.kt │ ├── ReificationD.kt │ ├── SameReturnType.kt │ ├── Select.kt │ └── Speakers.kt ├── DataClasses │ ├── CopyDataClass.kt │ ├── DataClasses.kt │ ├── HashCode.kt │ ├── Simple.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── DataTypes │ ├── Inference.kt │ ├── StringPlusNumber.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ └── Types.kt ├── DelegationTools │ ├── CarService.kt │ ├── DelegToolsSoln1.kt │ ├── DelegToolsSoln2.kt │ ├── DelegToolsSoln3.kt │ ├── MapAccessors.kt │ ├── NeverNull.kt │ ├── Team.kt │ └── TeamWithTraditions.kt ├── Destructuring │ ├── Computation.kt │ ├── ForLoop.kt │ ├── LoopWithIndex.kt │ ├── PairDestructuring.kt │ ├── Pairs.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Tuple.kt ├── DownCasting │ ├── Creature.kt │ ├── DownCastEx1.kt │ ├── DownCastEx2.kt │ ├── DownCastEx3.kt │ ├── FilterIsInstance.kt │ ├── FindType.kt │ ├── IsKeyword.kt │ ├── MutableSmartCast.kt │ ├── NarrowingUpcast.kt │ ├── Safe.kt │ └── Unsafe.kt ├── Enumerations │ ├── CheckingOptions.kt │ ├── Direction.kt │ ├── EnumImport.kt │ ├── Level.kt │ ├── RecursiveEnumImport.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── ExceptionHandling │ ├── CaptureImplementation.kt │ ├── DefiningExceptions.kt │ ├── GuaranteedCleanup.kt │ ├── Handlers.kt │ ├── Hierarchy.kt │ ├── LibraryException.kt │ ├── NewException.kt │ ├── Stacktrace.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── TryFinally.kt ├── Exceptions │ ├── AverageIncome.kt │ ├── AverageIncomeWithException.kt │ ├── AverageIncomeWithNull.kt │ ├── IntroducingCapture.kt │ ├── IntroducingNull.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── ToIntException.kt ├── ExpressionsStatements │ ├── AssigningAnIf.kt │ ├── Confusing.kt │ ├── ForIsAStatement.kt │ ├── PostfixVsPrefix.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── UnitReturnType.kt ├── ExtensionFunctions │ ├── BookExtensions.kt │ ├── Quote.kt │ ├── Quoting.kt │ ├── StrangeQuote.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── ExtensionLambdas │ ├── AnonymousFunction.kt │ ├── ExtensionLambdasSoln1.kt │ ├── ExtensionLambdasSoln2.kt │ ├── ExtensionLambdasSoln3.kt │ ├── ExtensionPolymorphism.kt │ ├── FuncReferences.kt │ ├── FunctionParameters.kt │ ├── LambdaUnitReturn.kt │ ├── ListsAndMaps.kt │ ├── Parameters.kt │ ├── Sandwich.kt │ ├── StringCreation.kt │ ├── Transform.kt │ └── Vanbo.kt ├── ExtensionProperties │ ├── AnyFromListOfStar.kt │ ├── GenericListExt.kt │ ├── ListOfStar.kt │ ├── StringIndices.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── FoldingLists │ ├── FoldRight.kt │ ├── FoldVsForLoop.kt │ ├── ReduceAndReduceRight.kt │ ├── RunningFold.kt │ ├── SumViaFold.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── Functions │ ├── MultiplyByFour.kt │ ├── MultiplyByThree.kt │ ├── MultiplyByTwo.kt │ ├── SayHello.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── HelloWorld │ ├── EmptyProgram.kt │ ├── HelloWorld.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── Task5.kt ├── HigherOrderFunctions │ ├── Any.kt │ ├── CallingReference.kt │ ├── IsPlus.kt │ ├── NullableFunction.kt │ ├── NullableReturn.kt │ ├── Repeat.kt │ ├── RepeatByInt.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── IfExpressions │ ├── If1.kt │ ├── If2.kt │ ├── If3.kt │ ├── If4.kt │ ├── If5.kt │ ├── If6.kt │ ├── OneOrTheOther.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── TrueOrFalse.kt ├── ImportanceOfLambdas │ ├── Closures.kt │ ├── Closures2.kt │ ├── Filter.kt │ ├── FilterEven.kt │ ├── FunctionClosure.kt │ ├── GreaterThan2.kt │ ├── StoringLambda.kt │ ├── Sum.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── InKeyword │ ├── CharRange.kt │ ├── FloatingPointRange.kt │ ├── InString.kt │ ├── IterationVsMembership.kt │ ├── MembershipInRange.kt │ ├── MembershipUsingBounds.kt │ ├── StringRange.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── Task5.kt ├── Inheritance │ ├── BasicInheritance.kt │ ├── GreatApe.kt │ ├── GreatApe2.kt │ ├── OpenAndFinalClasses.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── InheritanceExtensions │ ├── Adapter.kt │ ├── ComposeAdapter.kt │ ├── Convention.kt │ ├── DeviceExtensions.kt │ ├── DeviceMembers.kt │ ├── ExtensionFuncs.kt │ ├── Heater.kt │ ├── InhExtensionsEx1.kt │ ├── InheritAdd.kt │ ├── NoExtOverride.kt │ ├── PrivateAccess.kt │ ├── Task1.kt │ ├── TemperatureDelta.kt │ └── UsefulLibrary.kt ├── InnerClasses │ ├── CounterFactory.kt │ ├── Hotel.kt │ ├── InnerClassInheritance.kt │ ├── InnerEx1.kt │ ├── InnerEx2.kt │ ├── InnerEx3.kt │ ├── LocalInnerClasses.kt │ └── QualifiedThis.kt ├── Interfaces │ ├── Computer.kt │ ├── Hotness.kt │ ├── PlayerInterface.kt │ ├── SAM.kt │ ├── SAMConversion.kt │ ├── SAMImplementation.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── IntroGenerics │ ├── AnyInstead.kt │ ├── GenericFunction.kt │ ├── GenericHolder.kt │ ├── GenericListExtensions.kt │ ├── RigidHolder.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── Lambdas │ ├── BasicLambda.kt │ ├── JoinToString.kt │ ├── LambdaAndNamedArgs.kt │ ├── LambdaIt.kt │ ├── LambdaTypeInference.kt │ ├── ListIndicesMap.kt │ ├── Mapping.kt │ ├── OmittingParentheses.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── TwoArgLambda.kt │ ├── Underscore.kt │ └── ZeroArguments.kt ├── LateInitialization │ ├── Bag.kt │ ├── BetterSuitcase.kt │ ├── FaultySuitcase.kt │ ├── IsInitialized.kt │ ├── LateInitSoln1.kt │ ├── LateInitSoln2.kt │ ├── LateInitSoln3.kt │ └── Suitcase.kt ├── LazyInitialization │ ├── LazyInitSoln1.kt │ ├── LazyInitSoln2.kt │ ├── LazyInitSoln3.kt │ ├── LazyInt.kt │ ├── LazySyntax.kt │ └── PropertyOptions.kt ├── Lists │ ├── ApparentlyMutableList.kt │ ├── IntList1.kt │ ├── IntList2.kt │ ├── ListUsefulFunction.kt │ ├── Lists.kt │ ├── MultipleListRefs.kt │ ├── MutListIsList.kt │ ├── MutableList.kt │ ├── OutOfBounds.kt │ ├── ParameterizedReturn.kt │ ├── ParameterizedTypes.kt │ ├── PlusAssignPuzzle.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── LocalFunctions │ ├── CustomLabel.kt │ ├── InterestingSessions.kt │ ├── LabeledReturn.kt │ ├── LocalExtensions.kt │ ├── LocalFunctionReference.kt │ ├── LocalFunctions.kt │ ├── ReturnFromFun.kt │ ├── ReturnInsideLambda.kt │ ├── ReturningFunc.kt │ ├── Session.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── Logging │ ├── AtomicLog.kt │ ├── BasicLogging.kt │ ├── LoggingSoln1.kt │ ├── LoggingSoln2.kt │ ├── LoggingSoln3.kt │ ├── SimpleLoggingStrategy.kt │ └── UseAtomicLog.kt ├── LoopingAndRanges │ ├── AddingIntToChar.kt │ ├── DefiningRanges.kt │ ├── ForWithCharRange.kt │ ├── ForWithRanges.kt │ ├── HasChar.kt │ ├── IndexIntoString.kt │ ├── IterateOverString.kt │ ├── RepeatHi.kt │ ├── RepeatThreeTimes.kt │ ├── SumUsingRange.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── Task5.kt ├── ManipulatingLists │ ├── Flatten.kt │ ├── FlattenAndFlatMap.kt │ ├── PlayingCards.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ ├── Task6.kt │ ├── Task7.kt │ ├── WhyFlatMap.kt │ ├── ZipAndTransform.kt │ ├── Zipper.kt │ └── ZippingWithNext.kt ├── Maps │ ├── ContactMap.kt │ ├── GetValue.kt │ ├── Maps.kt │ ├── MutableMaps.kt │ ├── ReadOnlyMaps.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── MemberReferences │ ├── ConstructorReference.kt │ ├── ExtensionReference.kt │ ├── FunctionReference.kt │ ├── MemberReferencesEx1.kt │ ├── PropertyReference.kt │ ├── SortWith.kt │ ├── Task2.kt │ ├── Task3.kt │ └── TopLevelFunctionRef.kt ├── NamedAndDefaultArgs │ ├── ArgumentOrder.kt │ ├── Color2.kt │ ├── Color3.kt │ ├── CreateString.kt │ ├── CreateString2.kt │ ├── Evaluation.kt │ ├── NamedArguments.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── TrimMargin.kt ├── NestedClasses │ ├── Airport.kt │ ├── FillIt.kt │ ├── LocalClasses.kt │ ├── NestedEx1.kt │ ├── NestedEx2.kt │ ├── NestedEx3.kt │ ├── NestedEx4.kt │ ├── NestedHouse.kt │ ├── ReturnLocal.kt │ ├── Ticket.kt │ └── WithinInterface.kt ├── NonNullAssertions │ ├── NonNullAssert.kt │ ├── NonNullAssertCall.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── ValueFromMap.kt ├── NothingType │ ├── CheckObject.kt │ ├── CheckObject2.kt │ ├── Fail.kt │ ├── InfiniteLoop.kt │ ├── ListOfNothing.kt │ ├── NothingTypeSoln1.kt │ ├── NothingTypeSoln2.kt │ ├── NothingTypeSoln3.kt │ └── Todo.kt ├── NullableExtensions │ ├── NullableExtension.kt │ ├── NullableParameter.kt │ ├── StringIsNullOr.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── NullableTypes │ ├── Amphibian.kt │ ├── Dereference.kt │ ├── ExplicitCheck.kt │ ├── NullInMaps.kt │ ├── NullableInMap.kt │ ├── NullableTypes.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── NumberTypes │ ├── BMIEnglish.kt │ ├── BMIMetric.kt │ ├── BiggestLong.kt │ ├── InferInt.kt │ ├── IntDivisionTruncates.kt │ ├── IntegerOverflow.kt │ ├── LongConstants.kt │ ├── Modulus.kt │ ├── OpOrder.kt │ ├── OpOrderParens.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ └── UsingLongs.kt ├── Objects │ ├── GlobalSharing.kt │ ├── ObjectEx1.kt │ ├── ObjectEx2.kt │ ├── ObjectEx3.kt │ ├── ObjectInheritance.kt │ ├── ObjectKeyword.kt │ ├── ObjectNesting.kt │ ├── Share1.kt │ └── Share2.kt ├── ObjectsEverywhere │ ├── Conversion.kt │ ├── IntRanges.kt │ ├── NumberConversions.kt │ ├── RangeSum.kt │ ├── Strings.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── Task5.kt ├── OperationsOnCollections │ ├── ByOperations.kt │ ├── CreatingLists.kt │ ├── FilterNotNull.kt │ ├── ListInit.kt │ ├── PairOfLists.kt │ ├── Partition.kt │ ├── Predicates.kt │ ├── SetOperations.kt │ ├── TakeOrDrop.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── OperatorOverloading │ ├── ArithmeticOperators.kt │ ├── Backticks.kt │ ├── Comparison.kt │ ├── ConfusingPrecedence.kt │ ├── ContainerAccess.kt │ ├── DefaultEquality.kt │ ├── DefiningEquality.kt │ ├── DifferentTypes.kt │ ├── EqualsForNullable.kt │ ├── Invoke.kt │ ├── InvokeFunctionType.kt │ ├── MemberOperator.kt │ ├── Molecule.kt │ ├── Num.kt │ ├── OpOverloadingSoln1.kt │ ├── OpOverloadingSoln2.kt │ ├── OpOverloadingSoln3.kt │ ├── Ranges.kt │ ├── StringInvoke.kt │ └── Swearing.kt ├── Overloading │ ├── MemberVsExtension.kt │ ├── OverloadedVsDefaultArg.kt │ ├── Overloading.kt │ ├── OverloadingAdd.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── WithDefaultArguments.kt │ └── WithoutDefaultArguments.kt ├── Packages │ ├── EquilateralTriangle.kt │ ├── FullyQualify.kt │ ├── ImportClass.kt │ ├── ImportEverything.kt │ ├── ImportNameChange.kt │ ├── ImportPythagorean.kt │ ├── PythagoreanTheorem.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Triangle.kt │ ├── aaa.kt │ └── bbb.kt ├── Polymorphism │ ├── FantasyGame.kt │ ├── Pet.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── Properties │ ├── AnUnchangingVar.kt │ ├── ChangingAVal.kt │ ├── Cup.kt │ ├── Cup2.kt │ ├── References.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── TopLevelProperty.kt ├── PropertyAccessors │ ├── Counter.kt │ ├── Data.kt │ ├── Default.kt │ ├── Hamsters.kt │ ├── Hamsters2.kt │ ├── LogChanges.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── Task5.kt ├── PropertyDelegation │ ├── Accessibility.kt │ ├── Add.kt │ ├── BasicRead.kt │ ├── BasicRead2.kt │ ├── BasicReadWrite.kt │ ├── BasicReadWrite2.kt │ ├── Configuration.kt │ ├── FibonacciProperty.kt │ ├── FileDelegate.kt │ ├── PropDelegationSoln1.kt │ ├── PropDelegationSoln2.kt │ ├── PropDelegationSoln3.kt │ └── PropDelegationSoln4.kt ├── Recursion │ ├── CallStack.kt │ ├── Factorial.kt │ ├── Fibonacci.kt │ ├── InfiniteRecursion.kt │ ├── Iteration.kt │ ├── RecursionLimits.kt │ ├── TailRecursiveSum.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── VerySlowFibonacci.kt ├── RepetitionWithWhile │ ├── AssignmentOperators.kt │ ├── DoWhileLoop.kt │ ├── IncrementOperator.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ └── WhileLoop.kt ├── ResourceCleanup │ ├── AutoCloseable.kt │ ├── ForEachLine.kt │ ├── ResourceCleanupSoln1.kt │ ├── ResourceCleanupSoln2.kt │ ├── ResourceCleanupSoln3.kt │ ├── Usable.kt │ └── UseLines.kt ├── SafeCallsAndElvis │ ├── ChainedCalls.kt │ ├── DereferenceNull.kt │ ├── ElvisCall.kt │ ├── ElvisOperator.kt │ ├── SafeCall.kt │ ├── SafeOperation.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── ScopeFunctions │ ├── AndNullability.kt │ ├── Blob.kt │ ├── Differences.kt │ ├── Gnome.kt │ ├── MapLookup.kt │ ├── NameTag.kt │ ├── Nesting.kt │ ├── NullGnome.kt │ ├── Task1.kt │ ├── Task2.kt │ └── Task3.kt ├── SealedClasses │ ├── SealedClasses.kt │ ├── SealedEx1.kt │ ├── SealedEx2.kt │ ├── SealedEx3.kt │ ├── SealedSubclasses.kt │ ├── SealedVsAbstract.kt │ ├── ThirdLevelSealed.kt │ └── UnSealed.kt ├── SecondaryConstructors │ ├── GardenItem.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── WithSecondary.kt ├── Sequences │ ├── DefineTakeIf.kt │ ├── EagerEvaluation.kt │ ├── EagerVsLazyEvaluation.kt │ ├── GenerateSequence1.kt │ ├── GenerateSequence2.kt │ ├── NoComputationYet.kt │ ├── NumberSequence2.kt │ ├── School1.kt │ ├── School2.kt │ ├── School3.kt │ ├── School4.kt │ ├── School5.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ ├── Task6.kt │ ├── Task7.kt │ ├── Task8.kt │ └── TerminalOperations.kt ├── Sets │ ├── MutableSet.kt │ ├── RemoveDuplicates.kt │ ├── Sets.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt ├── StringTemplates │ ├── ExpressionInTemplate.kt │ ├── StringConcatenation.kt │ ├── StringTemplates.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ └── TripleQuotes.kt ├── Summary1 │ ├── BasicFunctions.kt │ ├── Booleans.kt │ ├── DoWhile.kt │ ├── Hello.kt │ ├── IfExpression.kt │ ├── IfResult.kt │ ├── Membership.kt │ ├── NumberTypes.kt │ ├── Overflow.kt │ ├── RangeOfInt.kt │ ├── StrTemplates.kt │ ├── StringIteration.kt │ ├── Task1.kt │ ├── Task10.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ ├── Task6.kt │ ├── Task7.kt │ ├── Task8.kt │ ├── Task9.kt │ ├── ThreeQuotes.kt │ ├── Truncation.kt │ ├── UnitReturn.kt │ └── While.kt ├── Summary2 │ ├── ALibrary.kt │ ├── ASCIIMap.kt │ ├── ArraySpread.kt │ ├── AtomicTestCapture.kt │ ├── Boxes.kt │ ├── ClassBodies.kt │ ├── ColorSet.kt │ ├── ExplicitTyping.kt │ ├── GetterAndSetter.kt │ ├── JetPack.kt │ ├── ListCollection.kt │ ├── ListOfStrings.kt │ ├── MultipleListReferences.kt │ ├── PropertyReadWrite.kt │ ├── Quadratic.kt │ ├── ReadonlyVsMutableList.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ ├── Task6.kt │ ├── Task7.kt │ ├── Task8.kt │ ├── Temperature.kt │ ├── TicTacToe.kt │ ├── ToDoubleException.kt │ ├── UseALibrary.kt │ ├── UsingAtomicTest.kt │ ├── VarArgs.kt │ └── WildAnimals.kt ├── Testing │ ├── TDDFail.kt │ ├── TDDStillFails.kt │ ├── TDDWorks.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── TestingExample.kt │ ├── Trace1.kt │ └── UsingTrace.kt ├── TypeChecking │ ├── AnyName.kt │ ├── BeverageContainer.kt │ ├── BeverageContainer2.kt │ ├── BeverageContainer3.kt │ ├── Insects.kt │ ├── TypeCheck1.kt │ ├── TypeCheck2.kt │ ├── TypeCheck3.kt │ ├── TypeCheckingSoln1.kt │ ├── TypeCheckingSoln2a.kt │ ├── TypeCheckingSoln2b.kt │ └── TypeCheckingSoln3.kt ├── UnitTesting │ ├── Learner.kt │ ├── NoFramework.kt │ ├── StateMachine.kt │ └── UsingExpect.kt ├── Upcasting │ ├── Assignment.kt │ ├── Drawing.kt │ ├── Shapes.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── TrimmedMembers.kt │ └── UpcastExercise1.kt ├── UsingOperators │ ├── ComparableRange.kt │ ├── CompareTo.kt │ ├── DestructuringData.kt │ ├── DestructuringDuo.kt │ ├── DestructuringMap.kt │ ├── NewAngle.kt │ ├── OperatorPlus.kt │ ├── ReadOnlyAndPlus.kt │ ├── Unexpected.kt │ ├── UsingOperatorsSoln1.kt │ ├── UsingOperatorsSoln2.kt │ └── UsingOperatorsSoln3.kt ├── VarAndVal │ ├── AVarIsMutable.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ ├── Vals.kt │ └── Vars.kt ├── Varargs │ ├── ListOf.kt │ ├── MainArgConversion.kt │ ├── MainArgs.kt │ ├── SpreadOperator.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ ├── Task5.kt │ ├── TwoFunctionsWithVarargs.kt │ ├── VarargLikeList.kt │ ├── VarargSum.kt │ └── VariableArgList.kt ├── Visibility │ ├── Cookie.kt │ ├── MultipleRef.kt │ ├── ObserveAnimals.kt │ ├── RecordAnimals.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ ├── Task4.kt │ └── Task5.kt ├── WhenExpressions │ ├── AnalyzeInput.kt │ ├── BmiWhen.kt │ ├── GermanOrdinals.kt │ ├── MatchingAgainstVals.kt │ ├── MixColors.kt │ ├── Task1.kt │ ├── Task2.kt │ ├── Task3.kt │ └── Task4.kt └── interoperability │ ├── AnnotateThrows.kt │ ├── AnnotatedJTool.java │ ├── AnnotatedJava.kt │ ├── BigFibonacci.kt │ ├── BigInt.kt │ ├── CallTopLevelFunction.java │ ├── CallTopLevelFunction2.java │ ├── CatchChecked.java │ ├── Chameleon.java │ ├── ChangeName.kt │ ├── CollectionStructure.kt │ ├── ExtensionsToJavaClass.kt │ ├── HiddenArrayList.kt │ ├── JTool.java │ ├── JavaChecked.java │ ├── JavaList.kt │ ├── JavaWrapper.java │ ├── KotlinChecked.kt │ ├── KotlinClass.kt │ ├── KotlinDataClass.kt │ ├── KotlinWrapper.kt │ ├── MakeSalad.java │ ├── NPEOnPlatformType.kt │ ├── PlatformTypes.kt │ ├── Random.kt │ ├── ReadOnlyByDefault.kt │ ├── ReadOnlyCollections.kt │ ├── TopLevelFunction.kt │ ├── UseBeanClass.kt │ ├── UseDataClass.java │ └── UsingKotlinClass.java ├── README.md ├── Tests ├── AbstractTestExamples.kt ├── TestExamples.java └── unittesting │ ├── LearnerTest.kt │ ├── SampleTest.kt │ ├── StateMachineTest.kt │ ├── UnitTestingSoln1.kt │ ├── UnitTestingSoln2.kt │ └── UnitTestingSoln3.kt ├── build.gradle.kts ├── buildSrc ├── build.gradle.kts └── src │ └── main │ └── kotlin │ └── generating │ └── GenerateTests.kt ├── etc ├── ExcludedExamples │ └── FromKotlin │ │ ├── BeanClass.java │ │ ├── DisplayList.kt │ │ ├── Random.kt │ │ └── UseBeanClass.kt ├── Experiments │ ├── AssistedLatentTyping.kt │ ├── Capture.kt │ ├── CombineToString.kt │ ├── ContinuedFractionCalc.kt │ ├── Coroutines1.kt │ ├── Coroutines2.kt │ ├── Covariant.kt │ ├── DogAndRobot.kt │ ├── DogAndRobot2.kt │ ├── DogAndRobot3.kt │ ├── Fibonacci.kt │ ├── FilterByInstance.kt │ ├── Invariant.java │ ├── JHelper.java │ ├── LambdaVariations.kt │ ├── NickName.kt │ ├── Phi.kt │ ├── PropertyDelegation.kt │ ├── Reified.kt │ ├── Reified2.kt │ ├── ToString.kt │ ├── TypeInfo.kt │ ├── TypeInfoNull.kt │ ├── UnpackInLambda.kt │ ├── UseJHelper.kt │ └── buildjar.bat ├── GenerateReadmeTOC.bat ├── GenerateReadmeTOC.py ├── ObjectOrientedDesign │ ├── build.gradle.kts │ └── settings.gradle.kts ├── makefile ├── test-old.bat └── usingrun.md ├── gradle.properties ├── gradle ├── tasks.gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── images ├── buildgradle.png ├── helloworld.png ├── main.png ├── runhelloworld.png └── runmain.png ├── settings.config ├── settings.gradle.kts ├── test.bat └── test.sh /Copyright.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/Copyright.txt -------------------------------------------------------------------------------- /Examples/Abstract/AbstractKeyword.kt: -------------------------------------------------------------------------------- 1 | // Abstract/AbstractKeyword.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package abstractclasses 4 | 5 | abstract class WithProperty { 6 | abstract val x: Int 7 | } 8 | 9 | abstract class WithFunctions { 10 | abstract fun f(): Int 11 | abstract fun g(n: Double) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Abstract/MultipleInterfaceInheritance.kt: -------------------------------------------------------------------------------- 1 | // Abstract/MultipleInterfaceInheritance.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package multipleinheritance2 4 | 5 | interface Animal 6 | interface Mammal: Animal 7 | interface AquaticAnimal: Animal 8 | 9 | class Dolphin : Mammal, AquaticAnimal 10 | -------------------------------------------------------------------------------- /Examples/Abstract/NoMultipleInheritance.kt: -------------------------------------------------------------------------------- 1 | // Abstract/NoMultipleInheritance.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package multipleinheritance1 4 | 5 | open class Animal 6 | open class Mammal : Animal() 7 | open class AquaticAnimal : Animal() 8 | 9 | // More than one base class doesn't compile: 10 | // class Dolphin : Mammal(), AquaticAnimal() 11 | -------------------------------------------------------------------------------- /Examples/Abstract/NoStateInInterfaces.kt: -------------------------------------------------------------------------------- 1 | // Abstract/NoStateInInterfaces.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package abstractclasses 4 | 5 | interface IntList { 6 | val name: String 7 | // Doesn't compile: 8 | // val list = listOf(0) 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Abstract/PropertyAccessor.kt: -------------------------------------------------------------------------------- 1 | // Abstract/PropertyAccessor.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package abstractclasses 4 | import atomictest.eq 5 | 6 | interface PropertyAccessor { 7 | val a: Int 8 | get() = 11 9 | } 10 | 11 | class Impl : PropertyAccessor 12 | 13 | fun main() { 14 | Impl().a eq 11 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Abstract/Redundant.kt: -------------------------------------------------------------------------------- 1 | // Abstract/Redundant.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package abstractclasses 4 | 5 | interface Redundant { 6 | abstract val x: Int 7 | abstract fun f(): Int 8 | abstract fun g(n: Double) 9 | } 10 | 11 | interface Removed { 12 | val x: Int 13 | fun f(): Int 14 | fun g(n: Double) 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Abstract/StateOfAClass.kt: -------------------------------------------------------------------------------- 1 | // Abstract/StateOfAClass.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package abstractstate 4 | import atomictest.eq 5 | 6 | class IntList(val name: String) { 7 | val list = mutableListOf() 8 | } 9 | 10 | fun main() { 11 | val ints = IntList("numbers") 12 | ints.name eq "numbers" 13 | ints.list += 7 14 | ints.list eq listOf(7) 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Abstract/Task2.kt: -------------------------------------------------------------------------------- 1 | // Abstract/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package abstractClassesExercise2 4 | import atomictest.eq 5 | 6 | interface Movable { 7 | fun move() = "move" 8 | } 9 | 10 | interface Sleepable { 11 | fun sleepOn() = "sleep" 12 | } 13 | 14 | class Sofa: Movable, Sleepable 15 | 16 | fun main() { 17 | val sofa = Sofa() 18 | sofa.move() eq "move" 19 | sofa.sleepOn() eq "sleep" 20 | } 21 | -------------------------------------------------------------------------------- /Examples/BaseClassInit/NoArgConstructor.kt: -------------------------------------------------------------------------------- 1 | // BaseClassInit/NoArgConstructor.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package baseclassinit 4 | 5 | open class SuperClass1(val i: Int) 6 | class SubClass1(i: Int) : SuperClass1(i) 7 | 8 | open class SuperClass2 9 | class SubClass2 : SuperClass2() 10 | -------------------------------------------------------------------------------- /Examples/BaseClassInit/OtherConstructors.kt: -------------------------------------------------------------------------------- 1 | // BaseClassInit/OtherConstructors.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package baseclassinit 4 | import atomictest.eq 5 | 6 | open class Base(val i: Int) 7 | 8 | class Derived : Base { 9 | constructor(i: Int) : super(i) 10 | constructor() : this(9) 11 | } 12 | 13 | fun main() { 14 | val d1 = Derived(11) 15 | d1.i eq 11 16 | val d2 = Derived() 17 | d2.i eq 9 18 | } 19 | -------------------------------------------------------------------------------- /Examples/BaseClassInit/Task1.kt: -------------------------------------------------------------------------------- 1 | // BaseClassInit/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package baseClassInitializationExercise1 4 | 5 | open class A(open val s: String) 6 | open class B(override val s: String) : A(s) 7 | class C(override val s: String) : B(s) 8 | -------------------------------------------------------------------------------- /Examples/Booleans/Closed.kt: -------------------------------------------------------------------------------- 1 | // Booleans/Closed.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun isClosed(hour: Int) { 5 | val open = 9 6 | val closed = 20 7 | println("Operating hours: $open - $closed") 8 | val status = hour < open || hour >= closed 9 | println("Closed: $status") 10 | } 11 | 12 | fun main() = isClosed(6) 13 | /* Output: 14 | Operating hours: 9 - 20 15 | Closed: true 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/Booleans/Foo.kt: -------------------------------------------------------------------------------- 1 | // Booleans/Foo.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package booleansExercise4 4 | 5 | fun foo(): Boolean = true 6 | -------------------------------------------------------------------------------- /Examples/Booleans/Open2.kt: -------------------------------------------------------------------------------- 1 | // Booleans/Open2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun isOpen2(hour: Int) { 5 | val open = 9 6 | val closed = 20 7 | println("Operating hours: $open - $closed") 8 | val status = hour >= open && hour < closed 9 | println("Open: $status") 10 | } 11 | 12 | fun main() = isOpen2(6) 13 | /* Output: 14 | Operating hours: 9 - 20 15 | Open: false 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/Booleans/Task1.kt: -------------------------------------------------------------------------------- 1 | // Booleans/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package booleansExercise1 4 | 5 | // (178 + 131 > 209 + 99) && false 6 | val a: Boolean = false 7 | 8 | // 1 > 2 || 1 < 2 9 | val b: Boolean = true 10 | 11 | // (111 - 101 >= 10) && (11.0 > 10.99) && true 12 | val c: Boolean = true 13 | -------------------------------------------------------------------------------- /Examples/Booleans/Task3.kt: -------------------------------------------------------------------------------- 1 | // Booleans/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package booleansExercise3 4 | 5 | fun and(b1: Boolean, b2: Boolean): Boolean = 6 | if (b1) b2 else false 7 | 8 | fun or(b1: Boolean, b2: Boolean): Boolean = 9 | if (b1) true else b2 10 | 11 | fun main() { 12 | println(and(true, true)) // true 13 | println(or(true, false)) // true 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Booleans/Task4.kt: -------------------------------------------------------------------------------- 1 | // Booleans/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package booleansExercise4 4 | 5 | fun main() { 6 | println(foo()) 7 | } 8 | -------------------------------------------------------------------------------- /Examples/BreakAndContinue/DoWhileControl.kt: -------------------------------------------------------------------------------- 1 | // BreakAndContinue/DoWhileControl.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val nums = mutableListOf(0) 7 | var i = 0 8 | do { 9 | i += 4 10 | if (i == 8) continue 11 | if (i == 40) break 12 | nums.add(i) 13 | } while (i < 100) 14 | nums eq "[0, 4, 12, 16, 20, 24, 28, 32, 36]" 15 | } 16 | -------------------------------------------------------------------------------- /Examples/BreakAndContinue/WhileControl.kt: -------------------------------------------------------------------------------- 1 | // BreakAndContinue/WhileControl.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val nums = mutableListOf(0) 7 | var i = 0 8 | while (i < 100) { 9 | i += 4 10 | if (i == 8) continue 11 | if (i == 40) break 12 | nums.add(i) 13 | } 14 | nums eq "[0, 4, 12, 16, 20, 24, 28, 32, 36]" 15 | } 16 | -------------------------------------------------------------------------------- /Examples/BuildingMaps/GetOrPut.kt: -------------------------------------------------------------------------------- 1 | // BuildingMaps/GetOrPut.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val map = mapOf(1 to "one", 2 to "two") 7 | map.getOrElse(0) { "zero" } eq "zero" 8 | 9 | val mutableMap = map.toMutableMap() 10 | mutableMap.getOrPut(0) { "zero" } eq 11 | "zero" 12 | mutableMap eq "{1=one, 2=two, 0=zero}" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/BuildingMaps/SimilarOperation.kt: -------------------------------------------------------------------------------- 1 | // BuildingMaps/SimilarOperation.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val map = mapOf(1 to "one", 7 | -2 to "minus two") 8 | map.any { (key, _) -> key < 0 } eq true 9 | map.all { (key, _) -> key < 0 } eq false 10 | map.maxByOrNull { it.key }?.value eq "one" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/CheckInstructions/SingleArgRequire.kt: -------------------------------------------------------------------------------- 1 | // CheckInstructions/SingleArgRequire.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package checkinstructions 4 | import atomictest.* 5 | 6 | fun singleArgRequire(arg: Int): Int { 7 | require(arg > 5) 8 | return arg 9 | } 10 | 11 | fun main() { 12 | capture { 13 | singleArgRequire(5) 14 | } eq "IllegalArgumentException: " + 15 | "Failed requirement." 16 | singleArgRequire(6) eq 6 17 | } 18 | -------------------------------------------------------------------------------- /Examples/ClassDelegation/BasicDelegation.kt: -------------------------------------------------------------------------------- 1 | // ClassDelegation/BasicDelegation.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package classdelegation 4 | 5 | interface AI 6 | class A : AI 7 | 8 | class B(val a: A) : AI by a 9 | -------------------------------------------------------------------------------- /Examples/CompanionObjects/ObjectCounter.kt: -------------------------------------------------------------------------------- 1 | // CompanionObjects/ObjectCounter.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package companionobjects 4 | import atomictest.eq 5 | 6 | class Counted { 7 | companion object { 8 | private var count = 0 9 | } 10 | private val id = count++ 11 | override fun toString() = "#$id" 12 | } 13 | 14 | fun main() { 15 | List(4) { Counted() } eq "[#0, #1, #2, #3]" 16 | } 17 | -------------------------------------------------------------------------------- /Examples/CompanionObjects/ObjectFunctions.kt: -------------------------------------------------------------------------------- 1 | // CompanionObjects/ObjectFunctions.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package companionobjects 4 | import atomictest.eq 5 | 6 | class CompanionObjectFunction { 7 | companion object { 8 | private var n: Int = 0 9 | fun increment() = ++n 10 | } 11 | } 12 | 13 | fun main() { 14 | CompanionObjectFunction.increment() eq 1 15 | CompanionObjectFunction.increment() eq 2 16 | } 17 | -------------------------------------------------------------------------------- /Examples/ComplexConstructors/Exercise1.kt: -------------------------------------------------------------------------------- 1 | // ComplexConstructors/Exercise1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package complexConstructorsExercise1 4 | import atomictest.eq 5 | 6 | class Alien(name: String) { 7 | val myName: String 8 | init { 9 | myName = name 10 | } 11 | } 12 | 13 | fun main() { 14 | val alien = Alien("Pencilvester") 15 | alien.myName eq "Pencilvester" 16 | } 17 | -------------------------------------------------------------------------------- /Examples/ComplexConstructors/Exercise2.kt: -------------------------------------------------------------------------------- 1 | // ComplexConstructors/Exercise2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package complexConstructorsExercise2 4 | import atomictest.eq 5 | 6 | class SumChars(text: String) { 7 | val sum: Int 8 | init { 9 | fun calc() = text.sumOf { it.code } 10 | sum = calc() 11 | } 12 | } 13 | 14 | fun main() { 15 | SumChars("What?").sum eq 467 16 | } 17 | -------------------------------------------------------------------------------- /Examples/ComplexConstructors/SimpleConstructor.kt: -------------------------------------------------------------------------------- 1 | // ComplexConstructors/SimpleConstructor.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package complexconstructors 4 | import atomictest.eq 5 | 6 | class Alien(val name: String) 7 | 8 | fun main() { 9 | val alien = Alien("Pencilvester") 10 | alien.name eq "Pencilvester" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Composition/Embedding.kt: -------------------------------------------------------------------------------- 1 | // Composition/Embedding.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package composition 4 | 5 | class Features { 6 | fun f1() = "feature1" 7 | fun f2() = "feature2" 8 | } 9 | 10 | class Form { 11 | private val features = Features() 12 | fun operation1() = 13 | features.f2() + features.f1() 14 | fun operation2() = 15 | features.f1() + features.f2() 16 | } 17 | -------------------------------------------------------------------------------- /Examples/Composition/House1.kt: -------------------------------------------------------------------------------- 1 | // Composition/House1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package composition1 4 | 5 | interface Building 6 | interface Kitchen 7 | 8 | interface House: Building { 9 | val kitchen: Kitchen 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Composition/House2.kt: -------------------------------------------------------------------------------- 1 | // Composition/House2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package composition2 4 | 5 | interface Building 6 | interface Kitchen 7 | 8 | interface House: Building { 9 | val kitchen1: Kitchen 10 | val kitchen2: Kitchen 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Composition/House3.kt: -------------------------------------------------------------------------------- 1 | // Composition/House3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package composition3 4 | 5 | interface Building 6 | interface Kitchen 7 | 8 | interface House: Building { 9 | val kitchens: List 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Constructors/Arg.kt: -------------------------------------------------------------------------------- 1 | // Constructors/Arg.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | class Alien(name: String) { 5 | val greeting = "Poor $name!" 6 | } 7 | 8 | fun main() { 9 | val alien = Alien("Mr. Meeseeks") 10 | println(alien.greeting) 11 | // alien.name // Error // [1] 12 | } 13 | /* Output: 14 | Poor Mr. Meeseeks! 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/Constructors/DisplayAlienSpecies.kt: -------------------------------------------------------------------------------- 1 | // Constructors/DisplayAlienSpecies.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val krombopulosMichael = 6 | AlienSpecies("Gromflomite", 2, 2, 2) 7 | println(krombopulosMichael) 8 | } 9 | /* Sample output: 10 | AlienSpecies@4d7e1886 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/Constructors/Scientist.kt: -------------------------------------------------------------------------------- 1 | // Constructors/Scientist.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | class Scientist(val name: String) { 5 | override fun toString() = 6 | "Scientist('$name')" 7 | } 8 | 9 | fun main() { 10 | val zeep = Scientist("Zeep Xanflorp") 11 | println(zeep) 12 | } 13 | /* Output: 14 | Scientist('Zeep Xanflorp') 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/Constructors/Task1.kt: -------------------------------------------------------------------------------- 1 | // Constructors/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package constructorsExercise1 4 | 5 | class Floating(val d: Double) { 6 | override fun toString() = d.toString() 7 | } 8 | 9 | fun main() { 10 | val floating = Floating(2.0) 11 | println(floating) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Constructors/Task4.kt: -------------------------------------------------------------------------------- 1 | // Constructors/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package constructorsExercise4 4 | 5 | class Human( 6 | val name: String, 7 | val age: Int 8 | ) { 9 | override fun toString() = 10 | "Human(name='$name', age=$age)" 11 | } 12 | 13 | fun main() { 14 | val human = Human("Rick", 70) 15 | println(human) 16 | } 17 | /* Output: 18 | Human(name='Rick', age=70) 19 | */ 20 | -------------------------------------------------------------------------------- /Examples/Constructors/Wombat.kt: -------------------------------------------------------------------------------- 1 | // Constructors/Wombat.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | class Wombat 5 | 6 | fun main() { 7 | val wombat = Wombat() 8 | } 9 | -------------------------------------------------------------------------------- /Examples/CreatingClasses/Cat.kt: -------------------------------------------------------------------------------- 1 | // CreatingClasses/Cat.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | class Cat { 5 | fun meow() = "mrrrow!" 6 | } 7 | 8 | fun main() { 9 | val cat = Cat() 10 | // Call 'meow()' for 'cat': 11 | val m1 = cat.meow() 12 | println(m1) 13 | } 14 | /* Output: 15 | mrrrow! 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/CreatingClasses/Dog.kt: -------------------------------------------------------------------------------- 1 | // CreatingClasses/Dog.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | class Dog { 5 | fun bark() = "yip!" 6 | } 7 | 8 | fun main() { 9 | val dog = Dog() 10 | } 11 | -------------------------------------------------------------------------------- /Examples/CreatingClasses/Task1.kt: -------------------------------------------------------------------------------- 1 | // CreatingClasses/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatingClassesExercise1 4 | 5 | class SomeClass { 6 | fun a() { 7 | println("42") 8 | } 9 | 10 | fun b() { 11 | a() 12 | } 13 | 14 | fun c() { 15 | this.b() 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Examples/CreatingClasses/Task4.kt: -------------------------------------------------------------------------------- 1 | // CreatingClasses/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatingClassesExercise4 4 | 5 | fun main() { 6 | val s = "Hello!" 7 | println(s.uppercase()) 8 | println(s.lowercase()) 9 | } 10 | /* Output: 11 | HELLO! 12 | hello! 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/CreatingClasses/Task5.kt: -------------------------------------------------------------------------------- 1 | // CreatingClasses/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatingClassesExercise5 4 | 5 | fun cap(s: String) = s.capitalize() 6 | 7 | fun main() { 8 | println(cap("hi!")) 9 | println(cap("Hi!")) 10 | } 11 | /* Output: 12 | Hi! 13 | Hi! 14 | */ 15 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/BoxAssignment.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/BoxAssignment.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variance 4 | 5 | val catBox = Box(Cat()) 6 | // val petBox: Box = catBox 7 | // val anyBox: Box = catBox 8 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/CarCrate.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/CarCrate.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | import atomictest.eq 5 | 6 | class Car { 7 | override fun toString() = "Car" 8 | } 9 | 10 | class CarCrate(private var c: Car) { 11 | fun put(car: Car) { c = car } 12 | fun get(): Car = c 13 | } 14 | 15 | fun main() { 16 | val cc = CarCrate(Car()) 17 | val car: Car = cc.get() 18 | car eq "Car" 19 | } 20 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/CheckType.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/CheckType.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | import atomictest.eq 5 | 6 | inline fun check(t: Any) = t is T 7 | // fun check1(t: Any) = t is T // [1] 8 | 9 | fun main() { 10 | check("1") eq true 11 | check("1") eq false 12 | } 13 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/CovariantList.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/CovariantList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variance 4 | 5 | fun main() { 6 | val catList: List = listOf(Cat()) 7 | val petList: List = catList 8 | var mutablePetList: MutableList = 9 | mutableListOf(Cat()) 10 | mutablePetList.add(Dog()) 11 | // Type mismatch: 12 | // mutablePetList = 13 | // mutableListOf(Cat()) // [1] 14 | } 15 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/CovariantReturnTypes.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/CovariantReturnTypes.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variance 4 | 5 | interface Parent 6 | interface Child : Parent 7 | 8 | interface X { 9 | fun f(): Parent 10 | } 11 | 12 | interface Y : X { 13 | override fun f(): Child 14 | } 15 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/Crate.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/Crate.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | import atomictest.eq 5 | 6 | open class Crate(private var contents: T) { 7 | fun put(item: T) { contents = item } 8 | fun get(): T = contents 9 | } 10 | 11 | fun main() { 12 | val cc = Crate(Car()) 13 | val car: Car = cc.get() 14 | car eq "Car" 15 | } 16 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/Erasure.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/Erasure.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | 5 | fun main() { 6 | val strings = listOf("a", "b", "c") 7 | val all: List = listOf(1, 2, "x") 8 | useList(strings) 9 | useList(all) 10 | } 11 | 12 | fun useList(list: List) { 13 | // if (list is List) {} // [1] 14 | } 15 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/MapCrate.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/MapCrate.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | import atomictest.eq 5 | 6 | fun Crate.map(f:(T) -> R): List = 7 | listOf(f(get())) 8 | 9 | fun main() { 10 | Crate(Car()).map { it.toString() + "x" } eq 11 | "[Carx]" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/OutBoxAssignment.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/OutBoxAssignment.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variance 4 | 5 | val outCatBox: OutBox = OutBox(Cat()) 6 | val outPetBox: OutBox = outCatBox 7 | val outAnyBox: OutBox = outCatBox 8 | 9 | fun getting() { 10 | val cat: Cat = outCatBox.get() 11 | val pet: Pet = outPetBox.get() 12 | val any: Any = outAnyBox.get() 13 | } 14 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/Pets.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/Pets.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variance 4 | 5 | open class Pet 6 | class Cat : Pet() 7 | class Dog : Pet() 8 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/ReificationA.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/ReificationA.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | import kotlin.reflect.KClass 5 | 6 | fun a(kClass: KClass) { 7 | // Uses KClass 8 | } 9 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/ReificationB.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/ReificationB.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | 5 | // Doesn't compile because of erasure: 6 | // fun b() = a(T::class) 7 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/ReificationC.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/ReificationC.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | import kotlin.reflect.KClass 5 | 6 | fun c(kClass: KClass) = a(kClass) 7 | 8 | class K 9 | 10 | val kc = c(K::class) 11 | -------------------------------------------------------------------------------- /Examples/CreatingGenerics/ReificationD.kt: -------------------------------------------------------------------------------- 1 | // CreatingGenerics/ReificationD.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package creatinggenerics 4 | 5 | inline fun d() = a(T::class) 6 | 7 | val kd = d() 8 | -------------------------------------------------------------------------------- /Examples/DataClasses/Simple.kt: -------------------------------------------------------------------------------- 1 | // DataClasses/Simple.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package dataclasses 4 | import atomictest.eq 5 | 6 | data class Simple( 7 | val arg1: String, 8 | var arg2: Int 9 | ) 10 | 11 | fun main() { 12 | val s1 = Simple("Hi", 29) 13 | val s2 = Simple("Hi", 29) 14 | s1 eq "Simple(arg1=Hi, arg2=29)" 15 | s1 eq s2 16 | } 17 | -------------------------------------------------------------------------------- /Examples/DataTypes/Inference.kt: -------------------------------------------------------------------------------- 1 | // DataTypes/Inference.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val n = 1 + 1.2 6 | println(n) 7 | } 8 | /* Output: 9 | 2.2 10 | */ 11 | -------------------------------------------------------------------------------- /Examples/DataTypes/StringPlusNumber.kt: -------------------------------------------------------------------------------- 1 | // DataTypes/StringPlusNumber.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println("Sally" + 5.9) 6 | } 7 | /* Output: 8 | Sally5.9 9 | */ 10 | -------------------------------------------------------------------------------- /Examples/DataTypes/Task1.kt: -------------------------------------------------------------------------------- 1 | // DataTypes/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package dataTypesExercise1 4 | 5 | fun main() { 6 | var answer = 42 7 | // Type mismatch error: 8 | // answer = "unknown" 9 | println("Type mismatch") 10 | } 11 | -------------------------------------------------------------------------------- /Examples/DataTypes/Task3.kt: -------------------------------------------------------------------------------- 1 | // DataTypes/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package dataTypesExercise3 4 | 5 | // 'a' + 1 6 | val c1 = 'b' 7 | 8 | // 'a' + 25 9 | val c2 = 'z' 10 | 11 | // 'E' - 2 12 | val c3 = 'C' 13 | -------------------------------------------------------------------------------- /Examples/DataTypes/Task5.kt: -------------------------------------------------------------------------------- 1 | // DataTypes/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package dataTypesExercise5 4 | 5 | fun main() { 6 | val s = "Sally" + 5.9 7 | println(s) 8 | } 9 | -------------------------------------------------------------------------------- /Examples/Destructuring/LoopWithIndex.kt: -------------------------------------------------------------------------------- 1 | // Destructuring/LoopWithIndex.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.trace 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c') 7 | for ((index, value) in list.withIndex()) { 8 | trace("$index:$value") 9 | } 10 | trace eq "0:a 1:b 2:c" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Destructuring/PairDestructuring.kt: -------------------------------------------------------------------------------- 1 | // Destructuring/PairDestructuring.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import destructuring.compute 4 | import atomictest.eq 5 | 6 | fun main() { 7 | val (value, description) = compute(7) 8 | value eq 14 9 | description eq "High" 10 | } 11 | -------------------------------------------------------------------------------- /Examples/DownCasting/DownCastEx2.kt: -------------------------------------------------------------------------------- 1 | // DownCasting/DownCastEx2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package downcastingExercise2 4 | import downcasting.* 5 | import atomictest.eq 6 | 7 | fun main() { 8 | group.filterIsInstance() 9 | .map(Dog::bark) eq "[Yip!, Yip!]" 10 | group.filterIsInstance(Dog::class.java) 11 | .map(Dog::bark) eq "[Yip!, Yip!]" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/DownCasting/FilterIsInstance.kt: -------------------------------------------------------------------------------- 1 | // DownCasting/FilterIsInstance.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import downcasting.* 4 | import atomictest.eq 5 | 6 | fun main() { 7 | val humans1: List = 8 | group.filter { it is Human } 9 | humans1.size eq 2 10 | val humans2: List = 11 | group.filterIsInstance() 12 | humans2 eq humans1 13 | } 14 | -------------------------------------------------------------------------------- /Examples/DownCasting/FindType.kt: -------------------------------------------------------------------------------- 1 | // DownCasting/FindType.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package downcasting 4 | import atomictest.eq 5 | 6 | val group: List = listOf( 7 | Human(), Human(), Dog(), Alien(), Dog() 8 | ) 9 | 10 | fun main() { 11 | val dog = group 12 | .find { it is Dog } as Dog? // [1] 13 | dog?.bark() eq "Yip!" // [2] 14 | } 15 | -------------------------------------------------------------------------------- /Examples/DownCasting/IsKeyword.kt: -------------------------------------------------------------------------------- 1 | // DownCasting/IsKeyword.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import downcasting.* 4 | 5 | fun main() { 6 | val b1: Base = Derived1() // Upcast 7 | if(b1 is Derived1) 8 | b1.g() // Within scope of "is" check 9 | val b2: Base = Derived2() // Upcast 10 | if(b2 is Derived2) 11 | b2.h() // Within scope of "is" check 12 | } 13 | -------------------------------------------------------------------------------- /Examples/DownCasting/Safe.kt: -------------------------------------------------------------------------------- 1 | // DownCasting/Safe.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package downcasting 4 | import atomictest.eq 5 | 6 | fun dogBarkSafe(c: Creature) = 7 | (c as? Dog)?.bark() ?: "Not a Dog" 8 | 9 | fun main() { 10 | dogBarkSafe(Dog()) eq "Yip!" 11 | dogBarkSafe(Human()) eq "Not a Dog" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Enumerations/EnumImport.kt: -------------------------------------------------------------------------------- 1 | // Enumerations/EnumImport.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | import enumerations.Level.* // [1] 5 | 6 | fun main() { 7 | Overflow eq "Overflow" 8 | High eq "High" 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Enumerations/Level.kt: -------------------------------------------------------------------------------- 1 | // Enumerations/Level.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package enumerations 4 | import atomictest.eq 5 | 6 | enum class Level { 7 | Overflow, High, Medium, Low, Empty 8 | } 9 | 10 | fun main() { 11 | Level.Medium eq "Medium" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ExceptionHandling/Stacktrace.kt: -------------------------------------------------------------------------------- 1 | // ExceptionHandling/Stacktrace.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package stacktrace 4 | import exceptionhandling.Exception1 5 | 6 | fun function1(): Int = 7 | throw Exception1(-52) 8 | 9 | fun function2() = function1() 10 | 11 | fun function3() = function2() 12 | 13 | fun main() { 14 | // function3() 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Exceptions/AverageIncome.kt: -------------------------------------------------------------------------------- 1 | // Exceptions/AverageIncome.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package firstversion 4 | import atomictest.* 5 | 6 | fun averageIncome(income: Int, months: Int) = 7 | income / months 8 | 9 | fun main() { 10 | averageIncome(3300, 3) eq 1100 11 | capture { 12 | averageIncome(5000, 0) 13 | } eq "ArithmeticException: / by zero" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Exceptions/AverageIncomeWithNull.kt: -------------------------------------------------------------------------------- 1 | // Exceptions/AverageIncomeWithNull.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package withnull 4 | import atomictest.eq 5 | 6 | fun averageIncome(income: Int, months: Int) = 7 | if (months == 0) 8 | null 9 | else 10 | income / months 11 | 12 | fun main() { 13 | averageIncome(3300, 3) eq 1100 14 | averageIncome(5000, 0) eq null 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Exceptions/IntroducingCapture.kt: -------------------------------------------------------------------------------- 1 | // Exceptions/IntroducingCapture.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | capture { 7 | "1$".toInt() 8 | } eq "NumberFormatException: " + 9 | """For input string: "1$"""" 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Exceptions/IntroducingNull.kt: -------------------------------------------------------------------------------- 1 | // Exceptions/IntroducingNull.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | "1$".toIntOrNull() eq null 7 | } 8 | -------------------------------------------------------------------------------- /Examples/Exceptions/Task2.kt: -------------------------------------------------------------------------------- 1 | // Exceptions/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package exceptionsExercise2 4 | import atomictest.capture 5 | import atomictest.eq 6 | 7 | fun abort(s: String) { 8 | throw Exception(s) 9 | } 10 | 11 | fun main() { 12 | capture { 13 | abort("Stop!") 14 | } eq "Exception: Stop!" 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Exceptions/Task4.kt: -------------------------------------------------------------------------------- 1 | // Exceptions/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package exceptionsExercise4 4 | 5 | fun foo() { 6 | throw IllegalStateException("something is wrong") 7 | } 8 | 9 | fun bar() { 10 | foo() 11 | } 12 | 13 | fun main() { 14 | // bar() // Uncomment this to see exception 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Exceptions/ToIntException.kt: -------------------------------------------------------------------------------- 1 | // Exceptions/ToIntException.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package exceptions 4 | 5 | fun erroneousCode() { 6 | // Uncomment this line to get an exception: 7 | // val i = "1$".toInt() // [1] 8 | } 9 | 10 | fun main() { 11 | erroneousCode() 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ExpressionsStatements/Confusing.kt: -------------------------------------------------------------------------------- 1 | // ExpressionsStatements/Confusing.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var i = 1 6 | println(i++ + ++i) 7 | } 8 | -------------------------------------------------------------------------------- /Examples/ExpressionsStatements/ForIsAStatement.kt: -------------------------------------------------------------------------------- 1 | // ExpressionsStatements/ForIsAStatement.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | // Can't do this: 6 | // val f = for(i in 1..10) {} 7 | // Compiler error message: 8 | // for is not an expression, and 9 | // only expressions are allowed here 10 | } 11 | -------------------------------------------------------------------------------- /Examples/ExpressionsStatements/PostfixVsPrefix.kt: -------------------------------------------------------------------------------- 1 | // ExpressionsStatements/PostfixVsPrefix.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var i = 10 6 | println(i++) 7 | println(i) 8 | var j = 20 9 | println(++j) 10 | println(j) 11 | } 12 | /* Output: 13 | 10 14 | 11 15 | 21 16 | 21 17 | */ 18 | -------------------------------------------------------------------------------- /Examples/ExpressionsStatements/Task1.kt: -------------------------------------------------------------------------------- 1 | // ExpressionsStatements/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package expressionsAndStatementsExercise1 4 | 5 | fun main() { 6 | println(println(1)) 7 | } 8 | -------------------------------------------------------------------------------- /Examples/ExpressionsStatements/Task3.kt: -------------------------------------------------------------------------------- 1 | // ExpressionsStatements/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package expressionsAndStatementsExercise3 4 | 5 | /* 6 | var i = 1 7 | println(i-- - --i) 8 | */ 9 | val yourGuess: Int = 2 10 | -------------------------------------------------------------------------------- /Examples/ExpressionsStatements/Task4.kt: -------------------------------------------------------------------------------- 1 | // ExpressionsStatements/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package expressionsAndStatementsExercise4 4 | 5 | fun main() { 6 | var x = 1 7 | x = 2 8 | println(x) 9 | } 10 | -------------------------------------------------------------------------------- /Examples/ExpressionsStatements/UnitReturnType.kt: -------------------------------------------------------------------------------- 1 | // ExpressionsStatements/UnitReturnType.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun unitFun() = Unit 5 | 6 | fun main() { 7 | println(unitFun()) 8 | val u1: Unit = println(42) 9 | println(u1) 10 | val u2 = println(0) // Type inference 11 | println(u2) 12 | } 13 | /* Output: 14 | kotlin.Unit 15 | 42 16 | kotlin.Unit 17 | 0 18 | kotlin.Unit 19 | */ 20 | -------------------------------------------------------------------------------- /Examples/ExtensionFunctions/BookExtensions.kt: -------------------------------------------------------------------------------- 1 | // ExtensionFunctions/BookExtensions.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionfunctions 4 | import atomictest.eq 5 | 6 | class Book(val title: String) 7 | 8 | fun Book.categorize(category: String) = 9 | """title: "$title", category: $category""" 10 | 11 | fun main() { 12 | Book("Dracula").categorize("Vampire") eq 13 | """title: "Dracula", category: Vampire""" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/ExtensionFunctions/Quote.kt: -------------------------------------------------------------------------------- 1 | // ExtensionFunctions/Quote.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package other 4 | import atomictest.eq 5 | import extensionfunctions.doubleQuote 6 | import extensionfunctions.singleQuote 7 | 8 | fun main() { 9 | "Single".singleQuote() eq "'Single'" 10 | "Double".doubleQuote() eq "\"Double\"" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/ExtensionFunctions/Quoting.kt: -------------------------------------------------------------------------------- 1 | // ExtensionFunctions/Quoting.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionfunctions 4 | import atomictest.eq 5 | 6 | fun String.singleQuote() = "'$this'" 7 | fun String.doubleQuote() = "\"$this\"" 8 | 9 | fun main() { 10 | "Hi".singleQuote() eq "'Hi'" 11 | "Hi".doubleQuote() eq "\"Hi\"" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ExtensionFunctions/Task1.kt: -------------------------------------------------------------------------------- 1 | // ExtensionFunctions/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionFunctionsExercise1 4 | import atomictest.eq 5 | 6 | fun String.wrapInTag(tagName: String): String = "<$tagName>$this" 7 | 8 | fun main() { 9 | "cat".wrapInTag("animal") eq "cat" 10 | } 11 | -------------------------------------------------------------------------------- /Examples/ExtensionFunctions/Task2.kt: -------------------------------------------------------------------------------- 1 | // ExtensionFunctions/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionFunctionsExercise2 4 | import atomictest.eq 5 | 6 | fun Int.isOdd(): Boolean = this % 2 == 1 7 | 8 | fun Int.isEven(): Boolean = !isOdd() 9 | 10 | fun main() { 11 | 1.isOdd() eq true 12 | 2.isEven() eq true 13 | 13.isEven() eq false 14 | } 15 | -------------------------------------------------------------------------------- /Examples/ExtensionFunctions/Task4.kt: -------------------------------------------------------------------------------- 1 | // ExtensionFunctions/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionFunctionsExercise4 4 | import atomictest.eq 5 | 6 | class Book(val title: String) 7 | 8 | fun Book.categorize(category: String) = 9 | """title: "$title", category: $category""" 10 | 11 | fun main() { 12 | Book("Dracula").categorize("Vampire") eq 13 | """title: "Dracula", category: Vampire""" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/ExtensionLambdas/AnonymousFunction.kt: -------------------------------------------------------------------------------- 1 | // ExtensionLambdas/AnonymousFunction.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionlambdas 4 | import atomictest.eq 5 | 6 | fun exec( 7 | arg1: Int, arg2: Int, 8 | f: Int.(Int) -> Boolean 9 | ) = arg1.f(arg2) 10 | 11 | fun main() { 12 | exec(10, 2, fun Int.(d: Int): Boolean { 13 | return this % d == 0 14 | }) eq true 15 | } 16 | -------------------------------------------------------------------------------- /Examples/ExtensionProperties/AnyFromListOfStar.kt: -------------------------------------------------------------------------------- 1 | // ExtensionProperties/AnyFromListOfStar.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list: List<*> = listOf(1, 2) 7 | val any: Any? = list[0] 8 | any eq 1 9 | } 10 | -------------------------------------------------------------------------------- /Examples/ExtensionProperties/GenericListExt.kt: -------------------------------------------------------------------------------- 1 | // ExtensionProperties/GenericListExt.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionproperties 4 | import atomictest.eq 5 | 6 | val List.firstOrNull: T? 7 | get() = if (isEmpty()) null else this[0] 8 | 9 | fun main() { 10 | listOf(1, 2, 3).firstOrNull eq 1 11 | listOf().firstOrNull eq null 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ExtensionProperties/ListOfStar.kt: -------------------------------------------------------------------------------- 1 | // ExtensionProperties/ListOfStar.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionproperties 4 | import atomictest.eq 5 | 6 | val List<*>.indices: IntRange 7 | get() = 0 until size 8 | 9 | fun main() { 10 | listOf(1).indices eq 0..0 11 | listOf('a', 'b', 'c', 'd').indices eq 0..3 12 | emptyList().indices eq IntRange.EMPTY 13 | } 14 | -------------------------------------------------------------------------------- /Examples/ExtensionProperties/StringIndices.kt: -------------------------------------------------------------------------------- 1 | // ExtensionProperties/StringIndices.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionproperties 4 | import atomictest.eq 5 | 6 | val String.indices: IntRange 7 | get() = 0 until length 8 | 9 | fun main() { 10 | "abc".indices eq 0..2 11 | } 12 | -------------------------------------------------------------------------------- /Examples/ExtensionProperties/Task2.kt: -------------------------------------------------------------------------------- 1 | // ExtensionProperties/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionPropertiesExercise2 4 | import atomictest.eq 5 | 6 | val List.reversed: List 7 | get() = reversed() 8 | 9 | fun main() { 10 | val list = listOf(1, 2, 3) 11 | list.reversed eq listOf(3, 2, 1) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/FoldingLists/FoldRight.kt: -------------------------------------------------------------------------------- 1 | // FoldingLists/FoldRight.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c', 'd') 7 | list.fold("*") { acc, elem -> 8 | "($acc) + $elem" 9 | } eq "((((*) + a) + b) + c) + d" 10 | list.foldRight("*") { elem, acc -> 11 | "$elem + ($acc)" 12 | } eq "a + (b + (c + (d + (*))))" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/FoldingLists/FoldVsForLoop.kt: -------------------------------------------------------------------------------- 1 | // FoldingLists/FoldVsForLoop.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 10, 100, 1000) 7 | var accumulator = 0 8 | val operation = 9 | { sum: Int, i: Int -> sum + i } 10 | for (i in list) { 11 | accumulator = operation(accumulator, i) 12 | } 13 | accumulator eq 1111 14 | } 15 | -------------------------------------------------------------------------------- /Examples/FoldingLists/SumViaFold.kt: -------------------------------------------------------------------------------- 1 | // FoldingLists/SumViaFold.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 10, 100, 1000) 7 | list.fold(0) { sum, n -> 8 | sum + n 9 | } eq 1111 10 | } 11 | -------------------------------------------------------------------------------- /Examples/FoldingLists/Task1.kt: -------------------------------------------------------------------------------- 1 | // FoldingLists/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package foldingListsExercise1 4 | import atomictest.eq 5 | 6 | fun List.size(): Int = 7 | fold(0) { length, _ -> 8 | length + 1 9 | } 10 | 11 | fun main() { 12 | val list = listOf(1, 2, 3) 13 | list.size() eq 3 14 | } 15 | -------------------------------------------------------------------------------- /Examples/FoldingLists/Task2.kt: -------------------------------------------------------------------------------- 1 | // FoldingLists/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package foldingListsExercise2 4 | import atomictest.eq 5 | 6 | fun List.count(predicate: (T) -> Boolean): Int = 7 | fold(0) { count, element -> 8 | if (predicate(element)) count + 1 else count 9 | } 10 | 11 | fun main() { 12 | val list = listOf(1, -2, 3) 13 | list.count { it > 0 } eq 2 14 | } 15 | -------------------------------------------------------------------------------- /Examples/FoldingLists/Task3.kt: -------------------------------------------------------------------------------- 1 | // FoldingLists/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package foldingListsExercise3 4 | import atomictest.eq 5 | 6 | fun List.any(predicate: (T) -> Boolean): Boolean = 7 | fold(false) { found, element -> 8 | if (predicate(element)) true else found 9 | } 10 | 11 | fun main() { 12 | val list = listOf(1, -2, 3) 13 | list.any { it < 0 } eq true 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Functions/MultiplyByFour.kt: -------------------------------------------------------------------------------- 1 | // Functions/MultiplyByFour.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun multiplyByFour(x: Int) = x * 4 5 | 6 | fun main() { 7 | val result: Int = multiplyByFour(5) 8 | println(result) 9 | } 10 | /* Output: 11 | 20 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/Functions/MultiplyByThree.kt: -------------------------------------------------------------------------------- 1 | // Functions/MultiplyByThree.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun multiplyByThree(x: Int): Int = x * 3 5 | 6 | fun main() { 7 | println(multiplyByThree(5)) 8 | } 9 | /* Output: 10 | 15 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/Functions/MultiplyByTwo.kt: -------------------------------------------------------------------------------- 1 | // Functions/MultiplyByTwo.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun multiplyByTwo(x: Int): Int { // [1] 5 | println("Inside multiplyByTwo") // [2] 6 | return x * 2 7 | } 8 | 9 | fun main() { 10 | val r = multiplyByTwo(5) // [3] 11 | println(r) 12 | } 13 | /* Output: 14 | Inside multiplyByTwo 15 | 10 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/Functions/SayHello.kt: -------------------------------------------------------------------------------- 1 | // Functions/SayHello.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun sayHello() { 5 | println("Hallo!") 6 | } 7 | 8 | fun sayGoodbye(): Unit { 9 | println("Auf Wiedersehen!") 10 | } 11 | 12 | fun main() { 13 | sayHello() 14 | sayGoodbye() 15 | } 16 | /* Output: 17 | Hallo! 18 | Auf Wiedersehen! 19 | */ 20 | -------------------------------------------------------------------------------- /Examples/Functions/Task1.kt: -------------------------------------------------------------------------------- 1 | // Functions/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package functionsExercise1 4 | 5 | fun squareInt(i: Int): Int = i * i 6 | 7 | fun main() { 8 | println(squareInt(2)) // 4 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Functions/Task2.kt: -------------------------------------------------------------------------------- 1 | // Functions/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package functionsExercise2 4 | 5 | fun getSum(a: Double, b: Double, c: Double): Double = a + b + c 6 | 7 | fun main() { 8 | println(getSum(1.0, 2.2, 3.4)) // 6.6 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Functions/Task3.kt: -------------------------------------------------------------------------------- 1 | // Functions/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package functionsExercise3 4 | 5 | fun duplicate(s: String): String = s + s 6 | 7 | fun main() { 8 | println(duplicate("abc")) // abcabc 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Functions/Task4.kt: -------------------------------------------------------------------------------- 1 | // Functions/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package functionsExercise4 4 | 5 | fun foo(): String { 6 | return "abc" 7 | } 8 | 9 | fun main() { 10 | println(foo()) 11 | } 12 | -------------------------------------------------------------------------------- /Examples/HelloWorld/EmptyProgram.kt: -------------------------------------------------------------------------------- 1 | // HelloWorld/EmptyProgram.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | // Program code here ... 6 | } 7 | -------------------------------------------------------------------------------- /Examples/HelloWorld/HelloWorld.kt: -------------------------------------------------------------------------------- 1 | // HelloWorld/HelloWorld.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println("Hello, world!") 6 | } 7 | /* Output: 8 | Hello, world! 9 | */ 10 | -------------------------------------------------------------------------------- /Examples/HelloWorld/Task1.kt: -------------------------------------------------------------------------------- 1 | // HelloWorld/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package helloWorldExercise1 4 | 5 | fun main() { 6 | println("Hello, Kotlin!") 7 | } 8 | -------------------------------------------------------------------------------- /Examples/HelloWorld/Task2.kt: -------------------------------------------------------------------------------- 1 | // HelloWorld/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package helloWorldExercise2 4 | 5 | fun main() { 6 | println("Hello,") 7 | println("Kotlin!") 8 | } 9 | -------------------------------------------------------------------------------- /Examples/HelloWorld/Task3.kt: -------------------------------------------------------------------------------- 1 | // HelloWorld/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package helloWorldExercise3 4 | 5 | fun main() { 6 | //println("Hello,") 7 | println("Kotlin!") 8 | } 9 | -------------------------------------------------------------------------------- /Examples/HelloWorld/Task4.kt: -------------------------------------------------------------------------------- 1 | // HelloWorld/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package helloWorldExercise4 4 | 5 | fun main() { 6 | println("Hello, Kotlin!") 7 | } 8 | -------------------------------------------------------------------------------- /Examples/HelloWorld/Task5.kt: -------------------------------------------------------------------------------- 1 | // HelloWorld/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package helloWorldExercise5 4 | 5 | fun main() { 6 | println("Hello, Kotlin!") 7 | } 8 | -------------------------------------------------------------------------------- /Examples/HigherOrderFunctions/CallingReference.kt: -------------------------------------------------------------------------------- 1 | // HigherOrderFunctions/CallingReference.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package higherorderfunctions 4 | import atomictest.eq 5 | 6 | val helloWorld: () -> String = 7 | { "Hello, world!" } 8 | 9 | val sum: (Int, Int) -> Int = 10 | { x, y -> x + y } 11 | 12 | fun main() { 13 | helloWorld() eq "Hello, world!" 14 | sum(1, 2) eq 3 15 | } 16 | -------------------------------------------------------------------------------- /Examples/HigherOrderFunctions/IsPlus.kt: -------------------------------------------------------------------------------- 1 | // HigherOrderFunctions/IsPlus.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package higherorderfunctions 4 | import atomictest.eq 5 | 6 | val isPlus: (Int) -> Boolean = { it > 0 } 7 | 8 | fun main() { 9 | listOf(1, 2, -3).any(isPlus) eq true 10 | } 11 | -------------------------------------------------------------------------------- /Examples/HigherOrderFunctions/NullableReturn.kt: -------------------------------------------------------------------------------- 1 | // HigherOrderFunctions/NullableReturn.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val transform: (String) -> Int? = 7 | { s: String -> s.toIntOrNull() } 8 | transform("112") eq 112 9 | transform("abc") eq null 10 | val x = listOf("112", "abc") 11 | x.mapNotNull(transform) eq "[112]" 12 | x.mapNotNull { it.toIntOrNull() } eq "[112]" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/HigherOrderFunctions/RepeatByInt.kt: -------------------------------------------------------------------------------- 1 | // HigherOrderFunctions/RepeatByInt.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | repeat(4) { trace("hi!") } 7 | trace eq "hi! hi! hi! hi!" 8 | } 9 | -------------------------------------------------------------------------------- /Examples/IfExpressions/If1.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/If1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | if (1 > 0) 6 | println("It's true!") 7 | if (10 < 11) { 8 | println("10 < 11") 9 | println("ten is less than eleven") 10 | } 11 | } 12 | /* Output: 13 | It's true! 14 | 10 < 11 15 | ten is less than eleven 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/IfExpressions/If2.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/If2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val x: Boolean = 1 >= 1 6 | if (x) 7 | println("It's true!") 8 | } 9 | /* Output: 10 | It's true! 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/IfExpressions/If3.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/If3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val n: Int = -11 6 | if (n > 0) 7 | println("It's positive") 8 | else 9 | println("It's negative or zero") 10 | } 11 | /* Output: 12 | It's negative or zero 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/IfExpressions/If4.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/If4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val n: Int = -11 6 | if (n > 0) 7 | println("It's positive") 8 | else if (n == 0) 9 | println("It's zero") 10 | else 11 | println("It's negative") 12 | } 13 | /* Output: 14 | It's negative 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/IfExpressions/If5.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/If5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val y: Boolean = false 6 | if (!y) 7 | println("!y is true") 8 | } 9 | /* Output: 10 | !y is true 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/IfExpressions/If6.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/If6.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val num = 10 6 | val result = if (num > 100) 4 else 42 7 | println(result) 8 | } 9 | /* Output: 10 | 42 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/IfExpressions/OneOrTheOther.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/OneOrTheOther.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun oneOrTheOther(exp: Boolean): String = 5 | if (exp) 6 | "True!" // No 'return' necessary 7 | else 8 | "False" 9 | 10 | fun main() { 11 | val x = 1 12 | println(oneOrTheOther(x == 1)) 13 | println(oneOrTheOther(x == 2)) 14 | } 15 | /* Output: 16 | True! 17 | False 18 | */ 19 | -------------------------------------------------------------------------------- /Examples/IfExpressions/Task1.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package ifExpressionsExercise1 4 | 5 | fun checkSign(number: Int): String = 6 | if (number > 0) 7 | "positive" 8 | else if (number < 0) 9 | "negative" 10 | else 11 | "zero" 12 | 13 | fun main() { 14 | println(checkSign(-19)) // negative 15 | } 16 | -------------------------------------------------------------------------------- /Examples/IfExpressions/Task2.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package ifExpressionsExercise2 4 | 5 | fun abs(number: Int): Int = 6 | if (number >= 0) number else -number 7 | 8 | fun main() { 9 | println(abs(-19)) // 19 10 | } 11 | -------------------------------------------------------------------------------- /Examples/IfExpressions/Task3.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package ifExpressionsExercise3 4 | 5 | fun findMax(first: Int, second: Int): Int = 6 | if (first > second) first else second 7 | 8 | fun main() { 9 | println(findMax(-1, 4)) // 4 10 | } 11 | -------------------------------------------------------------------------------- /Examples/IfExpressions/Task4.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package ifExpressionsExercise4 4 | 5 | fun oneOrTheOther(exp: Boolean) = 6 | if (exp) 7 | "True!" 8 | else 9 | "False" 10 | 11 | fun main() { 12 | val x = 1 13 | println(oneOrTheOther(x == 1)) // True! 14 | } 15 | -------------------------------------------------------------------------------- /Examples/IfExpressions/TrueOrFalse.kt: -------------------------------------------------------------------------------- 1 | // IfExpressions/TrueOrFalse.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun trueOrFalse(exp: Boolean): String { 5 | if (exp) 6 | return "It's true!" // [1] 7 | return "It's false" // [2] 8 | } 9 | 10 | fun main() { 11 | val b = 1 12 | println(trueOrFalse(b < 3)) 13 | println(trueOrFalse(b >= 3)) 14 | } 15 | /* Output: 16 | It's true! 17 | It's false 18 | */ 19 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/Closures.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/Closures.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 5, 7, 10) 7 | val divider = 5 8 | list.filter { it % divider == 0 } eq 9 | listOf(5, 10) 10 | } 11 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/Closures2.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/Closures2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 5, 7, 10) 7 | var sum = 0 8 | val divider = 5 9 | list.filter { it % divider == 0 } 10 | .forEach { sum += it } 11 | sum eq 15 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/Filter.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/Filter.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4) 7 | val even = list.filter { it % 2 == 0 } 8 | val greaterThan2 = list.filter { it > 2 } 9 | even eq listOf(2, 4) 10 | greaterThan2 eq listOf(3, 4) 11 | } 12 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/FunctionClosure.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/FunctionClosure.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package importanceoflambdas 4 | import atomictest.eq 5 | 6 | var x = 100 7 | 8 | fun useX() { 9 | x++ 10 | } 11 | 12 | fun main() { 13 | useX() 14 | x eq 101 15 | } 16 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/StoringLambda.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/StoringLambda.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4) 7 | val isEven = { e: Int -> e % 2 == 0 } 8 | list.filter(isEven) eq listOf(2, 4) 9 | list.any(isEven) eq true 10 | } 11 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/Sum.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/Sum.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 5, 7, 10) 7 | val divider = 5 8 | list.filter { it % divider == 0 } 9 | .sum() eq 15 10 | } 11 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/Task2.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package theImportanceOfLambdasExercise2 4 | import atomictest.eq 5 | 6 | fun filterNonBlank(strings: List): List = 7 | strings.filter { it.isNotBlank() } 8 | 9 | fun main() { 10 | filterNonBlank(listOf("", "a", " ")) eq listOf("a") 11 | } 12 | -------------------------------------------------------------------------------- /Examples/ImportanceOfLambdas/Task3.kt: -------------------------------------------------------------------------------- 1 | // ImportanceOfLambdas/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package theImportanceOfLambdasExercise3 4 | import atomictest.eq 5 | 6 | fun other(s: String): String = 7 | s.filterIndexed { index, _ -> index % 2 == 0 } 8 | 9 | fun main() { 10 | other("cement") eq "cmn" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/InKeyword/CharRange.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/CharRange.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun isDigit(ch: Char) = ch in '0'..'9' 5 | 6 | fun notDigit(ch: Char) = 7 | ch !in '0'..'9' // [1] 8 | 9 | fun main() { 10 | println(isDigit('a')) 11 | println(isDigit('5')) 12 | println(notDigit('z')) 13 | } 14 | /* Output: 15 | false 16 | true 17 | true 18 | */ 19 | -------------------------------------------------------------------------------- /Examples/InKeyword/InString.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/InString.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println('t' in "kotlin") 6 | println('a' in "kotlin") 7 | } 8 | /* Output: 9 | true 10 | false 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/InKeyword/IterationVsMembership.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/IterationVsMembership.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val values = 1..3 6 | for (v in values) { 7 | println("iteration $v") 8 | } 9 | val v = 2 10 | if (v in values) 11 | println("$v is a member of $values") 12 | } 13 | /* Output: 14 | iteration 1 15 | iteration 2 16 | iteration 3 17 | 2 is a member of 1..3 18 | */ 19 | -------------------------------------------------------------------------------- /Examples/InKeyword/MembershipInRange.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/MembershipInRange.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val percent = 35 6 | println(percent in 1..100) 7 | } 8 | /* Output: 9 | true 10 | */ 11 | -------------------------------------------------------------------------------- /Examples/InKeyword/MembershipUsingBounds.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/MembershipUsingBounds.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val percent = 35 6 | println(0 <= percent && percent <= 100) 7 | } 8 | /* Output: 9 | true 10 | */ 11 | -------------------------------------------------------------------------------- /Examples/InKeyword/StringRange.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/StringRange.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println("ab" in "aa".."az") 6 | println("ba" in "aa".."az") 7 | } 8 | /* Output: 9 | true 10 | false 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/InKeyword/Task1.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package theInKeywordExercise1 4 | 5 | fun getAlphabet(): String { 6 | var s = "" 7 | for (c in 'a'..'z') { 8 | s += c 9 | } 10 | return s 11 | } 12 | 13 | fun main() { 14 | println(getAlphabet()) // abcdefghijklmnopqrstuvwxyz 15 | } 16 | -------------------------------------------------------------------------------- /Examples/InKeyword/Task2.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package theInKeywordExercise2 4 | 5 | fun sumOfEven(n: Int): Int { 6 | var result = 0 7 | for (i in 0..n step 2) { 8 | result += i 9 | } 10 | return result 11 | } 12 | 13 | fun main() { 14 | println(sumOfEven(10)) // 30 15 | } 16 | -------------------------------------------------------------------------------- /Examples/InKeyword/Task3.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package theInKeywordExercise3 4 | 5 | fun isLowerCase(ch: Char): Boolean = ch in 'a'..'z' 6 | 7 | fun main() { 8 | println(isLowerCase('A')) // false 9 | println(isLowerCase('b')) // true 10 | } 11 | -------------------------------------------------------------------------------- /Examples/InKeyword/Task5.kt: -------------------------------------------------------------------------------- 1 | // InKeyword/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package theInKeywordExercise5 4 | 5 | fun foo() { 6 | println("foo") 7 | } 8 | -------------------------------------------------------------------------------- /Examples/Inheritance/BasicInheritance.kt: -------------------------------------------------------------------------------- 1 | // Inheritance/BasicInheritance.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package inheritance 4 | 5 | open class Base 6 | 7 | class Derived : Base() 8 | -------------------------------------------------------------------------------- /Examples/Inheritance/OpenAndFinalClasses.kt: -------------------------------------------------------------------------------- 1 | // Inheritance/OpenAndFinalClasses.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package inheritance 4 | 5 | // This class can be inherited: 6 | open class Parent 7 | 8 | class Child : Parent() 9 | 10 | // Child is not open, so this fails: 11 | // class GrandChild : Child() 12 | 13 | // This class can't be inherited: 14 | final class Single 15 | 16 | // The same as using 'final': 17 | class AnotherSingle 18 | -------------------------------------------------------------------------------- /Examples/InheritanceExtensions/Convention.kt: -------------------------------------------------------------------------------- 1 | // InheritanceExtensions/Convention.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package inheritanceextensions 4 | 5 | class X 6 | 7 | fun X.f() {} 8 | 9 | class Y 10 | 11 | fun Y.f() {} 12 | 13 | fun callF(x: X) = x.f() 14 | 15 | fun callF(y: Y) = y.f() 16 | 17 | fun main() { 18 | val x = X() 19 | val y = Y() 20 | x.f() 21 | y.f() 22 | callF(x) 23 | callF(y) 24 | } 25 | -------------------------------------------------------------------------------- /Examples/InheritanceExtensions/Heater.kt: -------------------------------------------------------------------------------- 1 | // InheritanceExtensions/Heater.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package inheritanceextensions 4 | import atomictest.eq 5 | 6 | open class Heater { 7 | fun heat(temperature: Int) = 8 | "heating to $temperature" 9 | } 10 | 11 | fun warm(heater: Heater) { 12 | heater.heat(70) eq "heating to 70" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/InheritanceExtensions/PrivateAccess.kt: -------------------------------------------------------------------------------- 1 | // InheritanceExtensions/PrivateAccess.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package inheritanceextensions 4 | import atomictest.eq 5 | 6 | class Z(var i: Int = 0) { 7 | private var j = 0 8 | fun increment() { 9 | i++ 10 | j++ 11 | } 12 | } 13 | 14 | fun Z.decrement() { 15 | i-- 16 | // j -- // Cannot access 17 | } 18 | -------------------------------------------------------------------------------- /Examples/InheritanceExtensions/UsefulLibrary.kt: -------------------------------------------------------------------------------- 1 | // InheritanceExtensions/UsefulLibrary.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package usefullibrary 4 | 5 | interface LibType { 6 | fun f1() 7 | fun f2() 8 | } 9 | 10 | fun utility1(lt: LibType) { 11 | lt.f1() 12 | lt.f2() 13 | } 14 | 15 | fun utility2(lt: LibType) { 16 | lt.f2() 17 | lt.f1() 18 | } 19 | -------------------------------------------------------------------------------- /Examples/Interfaces/SAM.kt: -------------------------------------------------------------------------------- 1 | // Interfaces/SAM.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interfaces 4 | 5 | fun interface ZeroArg { 6 | fun f(): Int 7 | } 8 | 9 | fun interface OneArg { 10 | fun g(n: Int): Int 11 | } 12 | 13 | fun interface TwoArg { 14 | fun h(i: Int, j: Int): Int 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Interfaces/SAMConversion.kt: -------------------------------------------------------------------------------- 1 | // Interfaces/SAMConversion.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interfaces 4 | import atomictest.trace 5 | 6 | fun interface Action { 7 | fun act() 8 | } 9 | 10 | fun delayAction(action: Action) { 11 | trace("Delaying...") 12 | action.act() 13 | } 14 | 15 | fun main() { 16 | delayAction { trace("Hey!") } 17 | trace eq "Delaying... Hey!" 18 | } 19 | -------------------------------------------------------------------------------- /Examples/IntroGenerics/GenericFunction.kt: -------------------------------------------------------------------------------- 1 | // IntroGenerics/GenericFunction.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package introgenerics 4 | import atomictest.eq 5 | 6 | fun identity(arg: T): T = arg 7 | 8 | fun main() { 9 | identity("Yellow") eq "Yellow" 10 | identity(1) eq 1 11 | val d: Dog = identity(Dog()) 12 | d.bark() eq "Ruff!" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/IntroGenerics/RigidHolder.kt: -------------------------------------------------------------------------------- 1 | // IntroGenerics/RigidHolder.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package introgenerics 4 | import atomictest.eq 5 | 6 | data class Automobile(val brand: String) 7 | 8 | class RigidHolder(private val a: Automobile) { 9 | fun getValue() = a 10 | } 11 | 12 | fun main() { 13 | val holder = RigidHolder(Automobile("BMW")) 14 | holder.getValue() eq 15 | "Automobile(brand=BMW)" 16 | } 17 | -------------------------------------------------------------------------------- /Examples/IntroGenerics/Task2.kt: -------------------------------------------------------------------------------- 1 | // IntroGenerics/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package introductionToGenericsExercise2 4 | import atomictest.eq 5 | 6 | fun List.reversed(): List { 7 | val result = mutableListOf() 8 | for (i in lastIndex downTo 0) { 9 | result += get(i) 10 | } 11 | return result 12 | } 13 | 14 | fun main() { 15 | val list = listOf(1, 2, 3) 16 | list.reversed() eq listOf(3, 2, 1) 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Lambdas/BasicLambda.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/BasicLambda.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4) 7 | val result = list.map({ n: Int -> "[$n]" }) 8 | result eq listOf("[1]", "[2]", "[3]", "[4]") 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Lambdas/JoinToString.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/JoinToString.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(9, 11, 23, 32) 7 | list.joinToString(" ") { "[$it]" } eq 8 | "[9] [11] [23] [32]" 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Lambdas/LambdaAndNamedArgs.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/LambdaAndNamedArgs.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(9, 11, 23, 32) 7 | list.joinToString( 8 | separator = " ", 9 | transform = { "[$it]" } 10 | ) eq "[9] [11] [23] [32]" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Lambdas/LambdaIt.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/LambdaIt.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4) 7 | val result = list.map({ "[$it]" }) 8 | result eq listOf("[1]", "[2]", "[3]", "[4]") 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Lambdas/LambdaTypeInference.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/LambdaTypeInference.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4) 7 | val result = list.map({ n -> "[$n]" }) 8 | result eq listOf("[1]", "[2]", "[3]", "[4]") 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Lambdas/ListIndicesMap.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/ListIndicesMap.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c') 7 | list.indices.map { 8 | "[$it]" 9 | } eq listOf("[0]", "[1]", "[2]") 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Lambdas/Mapping.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/Mapping.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c', 'd') 7 | val result = 8 | list.map({ "[${it.uppercaseChar()}]" }) 9 | result eq listOf("[A]", "[B]", "[C]", "[D]") 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Lambdas/OmittingParentheses.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/OmittingParentheses.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c', 'd') 7 | val result = 8 | list.map { "[${it.uppercaseChar()}]" } 9 | result eq listOf("[A]", "[B]", "[C]", "[D]") 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Lambdas/Task1.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package lambdasExercise1 4 | import atomictest.eq 5 | 6 | fun transform(list: List): List = 7 | list.map { it.length } 8 | 9 | fun main() { 10 | transform(listOf("abc", "ab")) eq listOf(3, 2) 11 | transform(listOf("", "abdef", "x")) eq listOf(0, 5, 1) 12 | transform(listOf("123456789")) eq listOf(9) 13 | } 14 | -------------------------------------------------------------------------------- /Examples/Lambdas/TwoArgLambda.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/TwoArgLambda.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c') 7 | list.mapIndexed { index, element -> 8 | "[$index: $element]" 9 | } eq listOf("[0: a]", "[1: b]", "[2: c]") 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Lambdas/Underscore.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/Underscore.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c') 7 | list.mapIndexed { index, _ -> 8 | "[$index]" 9 | } eq listOf("[0]", "[1]", "[2]") 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Lambdas/ZeroArguments.kt: -------------------------------------------------------------------------------- 1 | // Lambdas/ZeroArguments.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | run { -> trace("A Lambda") } 7 | run { trace("Without args") } 8 | trace eq """ 9 | A Lambda 10 | Without args 11 | """ 12 | } 13 | -------------------------------------------------------------------------------- /Examples/LateInitialization/Bag.kt: -------------------------------------------------------------------------------- 1 | // LateInitialization/Bag.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package lateinitialization 4 | 5 | interface Bag { 6 | fun setUp() 7 | } 8 | -------------------------------------------------------------------------------- /Examples/Lists/ApparentlyMutableList.kt: -------------------------------------------------------------------------------- 1 | // Lists/ApparentlyMutableList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | var list = listOf('X') // Immutable 7 | list += 'Y' // Appears to be mutable 8 | list eq "[X, Y]" 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Lists/IntList1.kt: -------------------------------------------------------------------------------- 1 | // Lists/IntList1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package listsExercise1 4 | 5 | class IntList(private val list: List) : Iterable { 6 | 7 | override fun iterator(): Iterator = list.iterator() 8 | 9 | operator fun get(index: Int): Int = list[index] 10 | 11 | override fun toString() = list.toString() 12 | 13 | fun size() = list.size 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Lists/IntList2.kt: -------------------------------------------------------------------------------- 1 | // Lists/IntList2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package listsExercise2 4 | 5 | class IntList(private val list: List) : Iterable { 6 | 7 | override fun iterator(): Iterator = list.iterator() 8 | 9 | operator fun get(index: Int): Int = list[index] 10 | 11 | override fun toString() = list.toString() 12 | 13 | fun size() = list.size 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Lists/MultipleListRefs.kt: -------------------------------------------------------------------------------- 1 | // Lists/MultipleListRefs.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val first = mutableListOf(1) 7 | val second: List = first 8 | second eq listOf(1) 9 | first.add(2) 10 | // second sees the change: 11 | second eq listOf(1, 2) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Lists/MutListIsList.kt: -------------------------------------------------------------------------------- 1 | // Lists/MutListIsList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package lists 4 | import atomictest.eq 5 | 6 | fun makeList(): List = 7 | mutableListOf(1, 2, 3) 8 | 9 | fun main() { 10 | // makeList() produces a read-only List: 11 | val list = makeList() 12 | // list.add(3) // Unresolved reference: add 13 | list eq listOf(1, 2, 3) 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Lists/MutableList.kt: -------------------------------------------------------------------------------- 1 | // Lists/MutableList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = mutableListOf() 7 | 8 | list.add(1) 9 | list.addAll(listOf(2, 3)) 10 | 11 | list += 4 12 | list += listOf(5, 6) 13 | 14 | list eq listOf(1, 2, 3, 4, 5, 6) 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Lists/OutOfBounds.kt: -------------------------------------------------------------------------------- 1 | // Lists/OutOfBounds.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | val ints = listOf(1, 2, 3) 7 | capture { 8 | ints[3] 9 | } contains 10 | listOf("ArrayIndexOutOfBoundsException") 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Lists/ParameterizedReturn.kt: -------------------------------------------------------------------------------- 1 | // Lists/ParameterizedReturn.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package lists 4 | import atomictest.eq 5 | 6 | // Return type is inferred: 7 | fun inferred(p: Char, q: Char) = 8 | listOf(p, q) 9 | 10 | // Explicit return type: 11 | fun explicit(p: Char, q: Char): List = 12 | listOf(p, q) 13 | 14 | fun main() { 15 | inferred('a', 'b') eq "[a, b]" 16 | explicit('y', 'z') eq "[y, z]" 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Lists/Task1.kt: -------------------------------------------------------------------------------- 1 | // Lists/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package listsExercise1 4 | import atomictest.eq 5 | 6 | fun findMax(list: IntList): Int { 7 | var max = 0 8 | for (e in list) { 9 | if (max <= e) { 10 | max = e 11 | } 12 | } 13 | return max 14 | } 15 | 16 | fun main() { 17 | val list = IntList(listOf(1, 2, 3, 2)) 18 | findMax(list) eq 3 19 | } 20 | -------------------------------------------------------------------------------- /Examples/Lists/Task2.kt: -------------------------------------------------------------------------------- 1 | // Lists/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package listsExercise2 4 | 5 | fun countOccurrences(list: IntList, number: Int): Int { 6 | var occurrences = 0 7 | for (e in list) { 8 | if (number == e) { 9 | occurrences++ 10 | } 11 | } 12 | return occurrences 13 | } 14 | 15 | fun main() { 16 | val list = IntList(listOf(1, 2, 3, 2)) 17 | println(countOccurrences(list, 2)) // 2 18 | } 19 | -------------------------------------------------------------------------------- /Examples/Lists/Task4.kt: -------------------------------------------------------------------------------- 1 | // Lists/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package listsExercise4 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c', 'd', 'e').subList(1, 3) 7 | println(list) 8 | } 9 | -------------------------------------------------------------------------------- /Examples/LocalFunctions/CustomLabel.kt: -------------------------------------------------------------------------------- 1 | // LocalFunctions/CustomLabel.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4, 5) 7 | val value = 3 8 | var result = "" 9 | list.forEach tag@{ // [1] 10 | result += "$it" 11 | if (it == value) return@tag // [2] 12 | } 13 | result eq "12345" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/LocalFunctions/LabeledReturn.kt: -------------------------------------------------------------------------------- 1 | // LocalFunctions/LabeledReturn.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4, 5) 7 | val value = 3 8 | var result = "" 9 | list.forEach { 10 | result += "$it" 11 | if (it == value) return@forEach 12 | } 13 | result eq "12345" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/LocalFunctions/LocalExtensions.kt: -------------------------------------------------------------------------------- 1 | // LocalFunctions/LocalExtensions.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | fun String.exclaim() = "$this!" 7 | "Hello".exclaim() eq "Hello!" 8 | "Hallo".exclaim() eq "Hallo!" 9 | "Bonjour".exclaim() eq "Bonjour!" 10 | "Ciao".exclaim() eq "Ciao!" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/LocalFunctions/ReturnFromFun.kt: -------------------------------------------------------------------------------- 1 | // LocalFunctions/ReturnFromFun.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4, 5) 7 | val value = 3 8 | var result = "" 9 | list.forEach { 10 | result += "$it" 11 | if (it == value) { 12 | result eq "123" 13 | return // [1] 14 | } 15 | } 16 | result eq "Never gets here" // [2] 17 | } 18 | -------------------------------------------------------------------------------- /Examples/LocalFunctions/ReturnInsideLambda.kt: -------------------------------------------------------------------------------- 1 | // LocalFunctions/ReturnInsideLambda.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import localfunctions.* 4 | import atomictest.eq 5 | 6 | fun main() { 7 | sessions.any { session -> 8 | if (session.title.contains("Kotlin") && 9 | session.speaker in favoriteSpeakers) { 10 | return@any true 11 | } 12 | // ... more checks 13 | false 14 | } eq true 15 | } 16 | -------------------------------------------------------------------------------- /Examples/LocalFunctions/Session.kt: -------------------------------------------------------------------------------- 1 | // LocalFunctions/Session.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package localfunctions 4 | 5 | class Session( 6 | val title: String, 7 | val speaker: String 8 | ) 9 | 10 | val sessions = listOf(Session( 11 | "Kotlin Coroutines", "Roman Elizarov")) 12 | 13 | val favoriteSpeakers = setOf("Roman Elizarov") 14 | -------------------------------------------------------------------------------- /Examples/LocalFunctions/Task1.kt: -------------------------------------------------------------------------------- 1 | // LocalFunctions/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package localFunctionsExercise1 4 | import atomictest.eq 5 | 6 | fun f(): Int { 7 | fun g(): Int { 8 | fun h() = 47 9 | return h() 10 | } 11 | return g() 12 | } 13 | 14 | fun main() { 15 | f() eq 47 16 | } 17 | -------------------------------------------------------------------------------- /Examples/Logging/BasicLogging.kt: -------------------------------------------------------------------------------- 1 | // Logging/BasicLogging.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package logging 4 | import mu.KLogging 5 | 6 | private val log = KLogging().logger 7 | 8 | fun main() { 9 | val msg = "Hello, Kotlin Logging!" 10 | log.trace(msg) 11 | log.debug(msg) 12 | log.info(msg) 13 | log.warn(msg) 14 | log.error(msg) 15 | } 16 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/AddingIntToChar.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/AddingIntToChar.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val ch: Char = 'a' 6 | println(ch + 25) 7 | println(ch < 'z') 8 | } 9 | /* Output: 10 | z 11 | true 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/DefiningRanges.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/DefiningRanges.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val range1 = 1..10 // [1] 6 | val range2 = 0 until 10 // [2] 7 | println(range1) 8 | println(range2) 9 | } 10 | /* Output: 11 | 1..10 12 | 0..9 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/ForWithCharRange.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/ForWithCharRange.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | for (c in 'a'..'z') { 6 | print(c) 7 | } 8 | } 9 | /* Output: 10 | abcdefghijklmnopqrstuvwxyz 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/HasChar.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/HasChar.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun hasChar(s: String, ch: Char): Boolean { 5 | for (c in s) { 6 | if (c == ch) return true 7 | } 8 | return false 9 | } 10 | 11 | fun main() { 12 | println(hasChar("kotlin", 't')) 13 | println(hasChar("kotlin", 'a')) 14 | } 15 | /* Output: 16 | true 17 | false 18 | */ 19 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/IndexIntoString.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/IndexIntoString.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val s = "abc" 6 | for (i in 0..s.lastIndex) { 7 | print(s[i] + 1) 8 | } 9 | } 10 | /* Output: 11 | bcd 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/IterateOverString.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/IterateOverString.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | for (ch in "Jnskhm ") { 6 | print(ch + 1) 7 | } 8 | } 9 | /* Output: 10 | Kotlin! 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/RepeatHi.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/RepeatHi.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | repeat(2) { 6 | println("hi!") 7 | } 8 | } 9 | /* Output: 10 | hi! 11 | hi! 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/RepeatThreeTimes.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/RepeatThreeTimes.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | for (i in 1..3) { 6 | println("Hey $i!") 7 | } 8 | } 9 | /* Output: 10 | Hey 1! 11 | Hey 2! 12 | Hey 3! 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/SumUsingRange.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/SumUsingRange.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var sum = 0 6 | for (n in 10..100) { 7 | sum += n 8 | } 9 | println("sum = $sum") 10 | } 11 | /* Output: 12 | sum = 5005 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/Task1.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package loopingAndRangesExercise1 4 | 5 | fun factorial(n: Int): Long { 6 | var result = 1L 7 | for (i in 1..n) { 8 | result *= i 9 | } 10 | return result 11 | } 12 | 13 | fun main() { 14 | println(factorial(10)) // 3628800 15 | } 16 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/Task3.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package loopingAndRangesExercise3 4 | 5 | fun sumOfEven(n: Int): Int { 6 | var result = 0 7 | for (i in 1..n) { 8 | if (i % 2 == 0) { 9 | result += i 10 | } 11 | } 12 | return result 13 | } 14 | 15 | fun main() { 16 | println(sumOfEven(10)) // 30 17 | } 18 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/Task4.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package loopingAndRangesExercise4 4 | 5 | fun showHalfTriangle(n: Int) { 6 | for (i in 1..n) { 7 | repeat(i) { 8 | print("#") 9 | } 10 | println() 11 | } 12 | } 13 | 14 | fun main() { 15 | showHalfTriangle(4) 16 | } 17 | /* Output: 18 | # 19 | ## 20 | ### 21 | #### 22 | */ 23 | -------------------------------------------------------------------------------- /Examples/LoopingAndRanges/Task5.kt: -------------------------------------------------------------------------------- 1 | // LoopingAndRanges/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package loopingAndRangesExercise5 4 | 5 | fun main() { 6 | val s = "abcd" 7 | 8 | } 9 | -------------------------------------------------------------------------------- /Examples/ManipulatingLists/Flatten.kt: -------------------------------------------------------------------------------- 1 | // ManipulatingLists/Flatten.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf( 7 | listOf(1, 2), 8 | listOf(4, 5), 9 | listOf(7, 8), 10 | ) 11 | list.flatten() eq "[1, 2, 4, 5, 7, 8]" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ManipulatingLists/Task1.kt: -------------------------------------------------------------------------------- 1 | // ManipulatingLists/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package manipulatingListsExercise1 4 | import atomictest.eq 5 | 6 | fun List.zipWithIndex(): List> = 7 | zip(indices) 8 | 9 | fun main() { 10 | val list = listOf('a', 'b', 'c') 11 | list.zipWithIndex() eq 12 | "[(a, 0), (b, 1), (c, 2)]" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/ManipulatingLists/Task2.kt: -------------------------------------------------------------------------------- 1 | // ManipulatingLists/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package manipulatingListsExercise2 4 | import atomictest.eq 5 | 6 | fun List.zipWithIndex(): List> = 7 | mapIndexed { index, e -> Pair(e, index) } 8 | 9 | fun main() { 10 | val list = listOf('a', 'b', 'c') 11 | list.zipWithIndex() eq 12 | "[(a, 0), (b, 1), (c, 2)]" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/ManipulatingLists/Task5.kt: -------------------------------------------------------------------------------- 1 | // ManipulatingLists/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package manipulatingListsExercise5 4 | import atomictest.eq 5 | 6 | fun List.flatMap(f: (T) -> List): List = 7 | map(f).flatten() 8 | 9 | fun main() { 10 | val list = listOf(3, 1, 4) 11 | 12 | list.flatMap { (0..it).toList() } eq 13 | listOf(0, 1, 2, 3, 0, 1, 0, 1, 2, 3, 4) 14 | } 15 | -------------------------------------------------------------------------------- /Examples/ManipulatingLists/Task6.kt: -------------------------------------------------------------------------------- 1 | // ManipulatingLists/Task6.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package manipulatingListsExercise6 4 | import atomictest.eq 5 | 6 | fun List>.flatten(): List = 7 | flatMap { it } 8 | 9 | fun main() { 10 | val listOfLists = listOf(listOf(1, 2, 3), listOf(4, 5, 6)) 11 | 12 | listOfLists.flatten() eq listOf(1, 2, 3, 4, 5, 6) 13 | } 14 | -------------------------------------------------------------------------------- /Examples/ManipulatingLists/Task7.kt: -------------------------------------------------------------------------------- 1 | // ManipulatingLists/Task7.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package manipulatingListsExercise7 4 | import atomictest.eq 5 | 6 | fun List.filter(f: (T) -> Boolean): List = 7 | flatMap { if (f(it)) listOf(it) else emptyList() } 8 | 9 | fun main() { 10 | val list = listOf(1, 12, 22, 31) 11 | list.filter { it.toString().contains("2") } eq 12 | listOf(12, 22) 13 | } 14 | -------------------------------------------------------------------------------- /Examples/ManipulatingLists/ZippingWithNext.kt: -------------------------------------------------------------------------------- 1 | // ManipulatingLists/ZippingWithNext.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c', 'd') 7 | 8 | list.zipWithNext() eq listOf( 9 | Pair('a', 'b'), 10 | Pair('b', 'c'), 11 | Pair('c', 'd')) 12 | 13 | list.zipWithNext { a, b -> "$a$b" } eq 14 | "[ab, bc, cd]" 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Maps/GetValue.kt: -------------------------------------------------------------------------------- 1 | // Maps/GetValue.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | val map = mapOf('a' to "attempt") 7 | map['b'] eq null 8 | capture { 9 | map.getValue('b') 10 | } eq "NoSuchElementException: " + 11 | "Key b is missing in the map." 12 | map.getOrDefault('a', "??") eq "attempt" 13 | map.getOrDefault('b', "??") eq "??" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Maps/MutableMaps.kt: -------------------------------------------------------------------------------- 1 | // Maps/MutableMaps.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val m = 7 | mutableMapOf(5 to "five", 6 to "six") 8 | m[5] eq "five" 9 | m[5] = "5ive" 10 | m[5] eq "5ive" 11 | m += 4 to "four" 12 | m eq mapOf(5 to "5ive", 13 | 4 to "four", 6 to "six") 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Maps/Task4.kt: -------------------------------------------------------------------------------- 1 | // Maps/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package mapsExercise4 4 | 5 | fun main() { 6 | val map = mapOf( 7 | 1 to "one", 8 | 2 to "two", 9 | 3 to "three", 10 | ) 11 | println(map) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/NamedAndDefaultArgs/ArgumentOrder.kt: -------------------------------------------------------------------------------- 1 | // NamedAndDefaultArgs/ArgumentOrder.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import color1.color 4 | import atomictest.eq 5 | 6 | fun main() { 7 | color(blue = 0, red = 99, green = 52) eq 8 | "(99, 52, 0)" 9 | color(red = 255, 255, 0) eq 10 | "(255, 255, 0)" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/NamedAndDefaultArgs/Color3.kt: -------------------------------------------------------------------------------- 1 | // NamedAndDefaultArgs/Color3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package color3 4 | import atomictest.eq 5 | 6 | class Color( 7 | val red: Int = 0, 8 | val green: Int = 0, 9 | val blue: Int = 0, 10 | ) { 11 | override fun toString() = 12 | "($red, $green, $blue)" 13 | } 14 | 15 | fun main() { 16 | Color(red = 77).toString() eq "(77, 0, 0)" 17 | } 18 | -------------------------------------------------------------------------------- /Examples/NamedAndDefaultArgs/CreateString.kt: -------------------------------------------------------------------------------- 1 | // NamedAndDefaultArgs/CreateString.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3,) 7 | list.toString() eq "[1, 2, 3]" 8 | list.joinToString() eq "1, 2, 3" 9 | list.joinToString(prefix = "(", 10 | postfix = ")") eq "(1, 2, 3)" 11 | list.joinToString(separator = ":") eq 12 | "1:2:3" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/NamedAndDefaultArgs/CreateString2.kt: -------------------------------------------------------------------------------- 1 | // NamedAndDefaultArgs/CreateString2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3) 7 | list.joinToString(". ", "", "!") eq 8 | "1. 2. 3!" 9 | list.joinToString(separator = ". ", 10 | postfix = "!") eq "1. 2. 3!" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/NestedClasses/LocalClasses.kt: -------------------------------------------------------------------------------- 1 | // NestedClasses/LocalClasses.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nestedclasses 4 | 5 | fun localClasses() { 6 | open class Amphibian 7 | class Frog : Amphibian() 8 | val amphibian: Amphibian = Frog() 9 | } 10 | -------------------------------------------------------------------------------- /Examples/NestedClasses/ReturnLocal.kt: -------------------------------------------------------------------------------- 1 | // NestedClasses/ReturnLocal.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nestedclasses 4 | 5 | interface Amphibian 6 | 7 | fun createAmphibian(): Amphibian { 8 | class Frog : Amphibian 9 | return Frog() 10 | } 11 | 12 | fun main() { 13 | val amphibian = createAmphibian() 14 | // amphibian as Frog 15 | } 16 | -------------------------------------------------------------------------------- /Examples/NonNullAssertions/NonNullAssert.kt: -------------------------------------------------------------------------------- 1 | // NonNullAssertions/NonNullAssert.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | var x: String? = "abc" 7 | x!! eq "abc" 8 | x = null 9 | capture { 10 | val s: String = x!! 11 | } eq "NullPointerException" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/NonNullAssertions/NonNullAssertCall.kt: -------------------------------------------------------------------------------- 1 | // NonNullAssertions/NonNullAssertCall.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val s: String? = "abc" 7 | s!!.length eq 3 8 | } 9 | -------------------------------------------------------------------------------- /Examples/NothingType/CheckObject2.kt: -------------------------------------------------------------------------------- 1 | // NothingType/CheckObject2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nothingtype 4 | 5 | fun failWithBadData(obj: Any?): Nothing = 6 | throw BadData("Needs String, got $obj") 7 | 8 | fun checkObject2(obj: Any?): String = 9 | (obj as? String) ?: failWithBadData(obj) 10 | 11 | fun main() { 12 | test(::checkObject2) 13 | } 14 | -------------------------------------------------------------------------------- /Examples/NothingType/Fail.kt: -------------------------------------------------------------------------------- 1 | // NothingType/Fail.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nothingtype 4 | import atomictest.* 5 | 6 | fun fail(i: Int): Nothing = 7 | throw Exception("fail($i)") 8 | 9 | fun main() { 10 | capture { 11 | fail(1) 12 | } eq "Exception: fail(1)" 13 | capture { 14 | fail(2) 15 | } eq "Exception: fail(2)" 16 | } 17 | -------------------------------------------------------------------------------- /Examples/NothingType/InfiniteLoop.kt: -------------------------------------------------------------------------------- 1 | // NothingType/InfiniteLoop.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nothingtype 4 | 5 | fun infinite(): Nothing { 6 | while (true) {} 7 | } 8 | -------------------------------------------------------------------------------- /Examples/NullableExtensions/NullableExtension.kt: -------------------------------------------------------------------------------- 1 | // NullableExtensions/NullableExtension.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nullableextensions 4 | import atomictest.eq 5 | 6 | fun String?.isNullOrEmpty(): Boolean = 7 | this == null || isEmpty() 8 | 9 | fun main() { 10 | "".isNullOrEmpty() eq true 11 | } 12 | -------------------------------------------------------------------------------- /Examples/NullableExtensions/NullableParameter.kt: -------------------------------------------------------------------------------- 1 | // NullableExtensions/NullableParameter.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nullableextensions 4 | import atomictest.eq 5 | 6 | fun isNullOrEmpty(s: String?): Boolean = 7 | s == null || s.isEmpty() 8 | 9 | fun main() { 10 | isNullOrEmpty(null) eq true 11 | isNullOrEmpty("") eq true 12 | } 13 | -------------------------------------------------------------------------------- /Examples/NullableExtensions/Task1.kt: -------------------------------------------------------------------------------- 1 | // NullableExtensions/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package extensionsForNullableTypesExercise1 4 | import atomictest.eq 5 | 6 | fun String?.orEmpty(): String = this ?: "" 7 | 8 | fun main() { 9 | 10 | null.orEmpty() eq "" 11 | 12 | "abc".orEmpty() eq "abc" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/NullableTypes/Amphibian.kt: -------------------------------------------------------------------------------- 1 | // NullableTypes/Amphibian.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nullabletypes 4 | 5 | class Amphibian 6 | 7 | enum class Species { 8 | Frog, Toad, Salamander, Caecilian 9 | } 10 | 11 | fun main() { 12 | val a1: Amphibian = Amphibian() 13 | val a2: Amphibian? = null 14 | val at1: Species = Species.Toad 15 | val at2: Species? = null 16 | } 17 | -------------------------------------------------------------------------------- /Examples/NullableTypes/Dereference.kt: -------------------------------------------------------------------------------- 1 | // NullableTypes/Dereference.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val s1: String = "abc" 7 | val s2: String? = s1 8 | 9 | s1.length eq 3 // [1] 10 | // Doesn't compile: 11 | // s2.length // [2] 12 | } 13 | -------------------------------------------------------------------------------- /Examples/NullableTypes/ExplicitCheck.kt: -------------------------------------------------------------------------------- 1 | // NullableTypes/ExplicitCheck.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val s: String? = "abc" 7 | if (s != null) 8 | s.length eq 3 9 | } 10 | -------------------------------------------------------------------------------- /Examples/NullableTypes/NullInMaps.kt: -------------------------------------------------------------------------------- 1 | // NullableTypes/NullInMaps.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val map = mapOf(0 to "yes", 1 to "no") 7 | map[2] eq null 8 | } 9 | -------------------------------------------------------------------------------- /Examples/NullableTypes/NullableInMap.kt: -------------------------------------------------------------------------------- 1 | // NullableTypes/NullableInMap.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val map = mapOf(0 to "yes", 1 to "no") 7 | val first: String? = map[0] 8 | val second: String? = map[2] 9 | first eq "yes" 10 | second eq null 11 | } 12 | -------------------------------------------------------------------------------- /Examples/NullableTypes/Task2.kt: -------------------------------------------------------------------------------- 1 | // NullableTypes/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package nullableTypesExercise2 4 | 5 | fun zilch(): String? = null 6 | fun zilch2(): String? = zilch() 7 | 8 | fun main() { 9 | var x: String? = zilch() 10 | var y: String? = zilch2() 11 | } 12 | -------------------------------------------------------------------------------- /Examples/NumberTypes/BiggestLong.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/BiggestLong.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println(Long.MAX_VALUE) 6 | } 7 | /* Output: 8 | 9223372036854775807 9 | */ 10 | -------------------------------------------------------------------------------- /Examples/NumberTypes/InferInt.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/InferInt.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val million = 1_000_000 // Infers Int 6 | println(million) 7 | } 8 | /* Output: 9 | 1000000 10 | */ 11 | -------------------------------------------------------------------------------- /Examples/NumberTypes/IntDivisionTruncates.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/IntDivisionTruncates.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val numerator: Int = 19 6 | val denominator: Int = 10 7 | println(numerator / denominator) 8 | } 9 | /* Output: 10 | 1 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/NumberTypes/IntegerOverflow.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/IntegerOverflow.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val i: Int = Int.MAX_VALUE 6 | println(i + i) 7 | } 8 | /* Output: 9 | -2 10 | */ 11 | -------------------------------------------------------------------------------- /Examples/NumberTypes/LongConstants.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/LongConstants.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val i = 0 // Infers Int 6 | val l1 = 0L // L creates Long 7 | val l2: Long = 0 // Explicit type 8 | println("$l1 $l2") 9 | } 10 | /* Output: 11 | 0 0 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/NumberTypes/Modulus.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/Modulus.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val numerator: Int = 19 6 | val denominator: Int = 10 7 | println(numerator % denominator) 8 | } 9 | /* Output: 10 | 9 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/NumberTypes/OpOrder.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/OpOrder.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println(45 + 5 * 6) 6 | } 7 | /* Output: 8 | 75 9 | */ 10 | -------------------------------------------------------------------------------- /Examples/NumberTypes/OpOrderParens.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/OpOrderParens.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println((45 + 5) * 6) 6 | } 7 | /* Output: 8 | 300 9 | */ 10 | -------------------------------------------------------------------------------- /Examples/NumberTypes/Task1.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package numberTypesExercise1 4 | 5 | // 11 / 3 6 | val a = 3 7 | 8 | // 11 % 3 9 | val b = 2 10 | 11 | // a * 3 + b 12 | val c = 11 13 | 14 | // 6 / 5.0 15 | val d = 1.2 16 | -------------------------------------------------------------------------------- /Examples/NumberTypes/Task2.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package numberTypesExercise2 4 | 5 | val million: Int = 1_000_000 6 | val millionType: String = "Int" 7 | 8 | val billion = 1_000_000_000 9 | val billionType: String = "Int" 10 | 11 | val trillion = 1_000_000_000_000 12 | val trillionType: String = "Long" 13 | 14 | val quintillion = 1_000_000_000_000_000_000 15 | val quintillionType: String = "Long" 16 | -------------------------------------------------------------------------------- /Examples/NumberTypes/Task3.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package numberTypesExercise3 4 | 5 | fun convertFahrenheitToCelsius(f: Int): Double = 6 | (f - 32) * 5.0 / 9 7 | 8 | fun convertCelsiusToFahrenheit(c: Int): Double = 9 | c * 9.0 / 5 + 32 10 | 11 | fun main() { 12 | println(convertFahrenheitToCelsius(68)) // 20.0 13 | println(convertCelsiusToFahrenheit(20)) // 68.0 14 | } 15 | -------------------------------------------------------------------------------- /Examples/NumberTypes/Task4.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package numberTypesExercise4 4 | 5 | fun convertToMilliseconds(hours: Int, minutes: Int, seconds: Int): Long = 6 | (((hours * 60L + minutes) * 60) + seconds) * 1000 7 | 8 | fun main() { 9 | println(convertToMilliseconds(1, 30, 0)) 10 | } 11 | -------------------------------------------------------------------------------- /Examples/NumberTypes/Task5.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package numberTypesExercise5 4 | 5 | fun main() { 6 | val x = 10 7 | println(x + 1) 8 | } 9 | -------------------------------------------------------------------------------- /Examples/NumberTypes/UsingLongs.kt: -------------------------------------------------------------------------------- 1 | // NumberTypes/UsingLongs.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val i = Int.MAX_VALUE 6 | println(0L + i + i) // [1] 7 | println(1_000_000 * 1_000_000L) // [2] 8 | } 9 | /* Output: 10 | 4294967294 11 | 1000000000000 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/Objects/GlobalSharing.kt: -------------------------------------------------------------------------------- 1 | // Objects/GlobalSharing.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objectsharing 4 | 5 | object Shared { 6 | var i: Int = 0 7 | } 8 | -------------------------------------------------------------------------------- /Examples/Objects/ObjectKeyword.kt: -------------------------------------------------------------------------------- 1 | // Objects/ObjectKeyword.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objects 4 | import atomictest.eq 5 | 6 | object JustOne { 7 | val n = 2 8 | fun f() = n * 10 9 | fun g() = this.n * 20 // [1] 10 | } 11 | 12 | fun main() { 13 | // val x = JustOne() // Error 14 | JustOne.n eq 2 15 | JustOne.f() eq 20 16 | JustOne.g() eq 40 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Objects/Share1.kt: -------------------------------------------------------------------------------- 1 | // Objects/Share1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objectshare1 4 | import objectsharing.Shared 5 | 6 | fun f() { 7 | Shared.i += 5 8 | } 9 | -------------------------------------------------------------------------------- /Examples/Objects/Share2.kt: -------------------------------------------------------------------------------- 1 | // Objects/Share2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objectshare2 4 | import objectsharing.Shared 5 | import objectshare1.f 6 | import atomictest.eq 7 | 8 | fun g() { 9 | Shared.i += 7 10 | } 11 | 12 | fun main() { 13 | f() 14 | g() 15 | Shared.i eq 12 16 | } 17 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/Conversion.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/Conversion.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val s = "123" 6 | println(s.toInt()) 7 | val i = 123 8 | println(i.toString()) 9 | } 10 | /* Output: 11 | 123 12 | 123 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/IntRanges.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/IntRanges.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val r1 = IntRange(0, 10) 6 | val r2 = IntRange(5, 7) 7 | println(r1) 8 | println(r2) 9 | } 10 | /* Output: 11 | 0..10 12 | 5..7 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/NumberConversions.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/NumberConversions.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun fraction(numerator: Long, denom: Long) = 5 | numerator.toDouble() / denom 6 | 7 | fun main() { 8 | val num = 1 9 | val den = 2 10 | val f = fraction(num.toLong(), den.toLong()) 11 | println(f) 12 | } 13 | /* Output: 14 | 0.5 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/RangeSum.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/RangeSum.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val r = IntRange(0, 10) 6 | println(r.sum()) 7 | } 8 | /* Output: 9 | 55 10 | */ 11 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/Strings.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/Strings.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val s = "AbcD" 6 | println(s.reversed()) 7 | println(s.lowercase()) 8 | } 9 | /* Output: 10 | DcbA 11 | abcd 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/Task1.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objectsEverywhereExercise1 4 | 5 | fun isPalindrome(s: String): Boolean = s.reversed() == s 6 | 7 | fun main() { 8 | println(isPalindrome("mom")) // true 9 | println(isPalindrome("street")) // false 10 | } 11 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/Task2.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objectsEverywhereExercise2 4 | 5 | fun isPalindrome(s: String): Boolean = 6 | s.reversed() == s 7 | 8 | fun isPalIgnoreCase(s: String): Boolean = 9 | isPalindrome(s.lowercase()) 10 | 11 | fun main() { 12 | println(isPalIgnoreCase("Mom")) // true 13 | } 14 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/Task4.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objectsEverywhereExercise4 4 | 5 | fun reverseDecimal(number: Int): Int = number.toString().reversed().toInt() 6 | 7 | fun main() { 8 | println(reverseDecimal(1234)) // 4321 9 | } 10 | -------------------------------------------------------------------------------- /Examples/ObjectsEverywhere/Task5.kt: -------------------------------------------------------------------------------- 1 | // ObjectsEverywhere/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package objectsEverywhereExercise5 4 | 5 | fun main() { 6 | val r = IntRange(0, 10) 7 | 8 | val s = "abc" 9 | 10 | } 11 | -------------------------------------------------------------------------------- /Examples/OperationsOnCollections/FilterNotNull.kt: -------------------------------------------------------------------------------- 1 | // OperationsOnCollections/FilterNotNull.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, null) 7 | list.filterNotNull() eq "[1, 2]" 8 | } 9 | -------------------------------------------------------------------------------- /Examples/OperationsOnCollections/ListInit.kt: -------------------------------------------------------------------------------- 1 | // OperationsOnCollections/ListInit.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val mutableList1 = 7 | MutableList(5, { 10 * (it + 1) }) 8 | mutableList1 eq "[10, 20, 30, 40, 50]" 9 | val mutableList2 = 10 | MutableList(5) { 10 * (it + 1) } 11 | mutableList2 eq "[10, 20, 30, 40, 50]" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/OperationsOnCollections/PairOfLists.kt: -------------------------------------------------------------------------------- 1 | // OperationsOnCollections/PairOfLists.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package operationsoncollections 4 | import atomictest.eq 5 | 6 | fun createPair() = Pair(1, "one") 7 | 8 | fun main() { 9 | val (i, s) = createPair() 10 | i eq 1 11 | s eq "one" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/OperationsOnCollections/SetOperations.kt: -------------------------------------------------------------------------------- 1 | // OperationsOnCollections/SetOperations.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val set = setOf("a", "ab", "ac") 7 | set.maxByOrNull { it.length }?.length eq 2 8 | set.filter { 9 | it.contains('b') 10 | } eq listOf("ab") 11 | set.map { it.length } eq listOf(1, 2, 2) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/OperationsOnCollections/TakeOrDrop.kt: -------------------------------------------------------------------------------- 1 | // OperationsOnCollections/TakeOrDrop.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf('a', 'b', 'c', 'X', 'Z') 7 | list.takeLast(3) eq "[c, X, Z]" 8 | list.takeLastWhile { it.isUpperCase() } eq 9 | "[X, Z]" 10 | list.drop(1) eq "[b, c, X, Z]" 11 | list.dropWhile { it.isLowerCase() } eq 12 | "[X, Z]" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/OperationsOnCollections/Task3.kt: -------------------------------------------------------------------------------- 1 | // OperationsOnCollections/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package operationsOnCollectionsExercise3 4 | import atomictest.eq 5 | 6 | fun sum(list: List): Int = 7 | list.filterNotNull().sum() 8 | 9 | fun main() { 10 | sum(listOf(1, 2, null)) eq 3 11 | } 12 | -------------------------------------------------------------------------------- /Examples/OperatorOverloading/ConfusingPrecedence.kt: -------------------------------------------------------------------------------- 1 | // OperatorOverloading/ConfusingPrecedence.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package operatoroverloading 4 | import atomictest.eq 5 | 6 | fun main() { 7 | val x: Int? = 1 8 | val y: Int = 2 9 | val sum = x ?: 0 + y 10 | sum eq 1 11 | (x ?: 0) + y eq 3 // [1] 12 | x ?: (0 + y) eq 1 // [2] 13 | } 14 | -------------------------------------------------------------------------------- /Examples/OperatorOverloading/DifferentTypes.kt: -------------------------------------------------------------------------------- 1 | // OperatorOverloading/DifferentTypes.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package operatoroverloading 4 | import atomictest.eq 5 | 6 | operator fun E.plus(i: Int) = E(v + i) 7 | 8 | fun main() { 9 | E(1) + 10 eq E(11) 10 | } 11 | -------------------------------------------------------------------------------- /Examples/OperatorOverloading/Num.kt: -------------------------------------------------------------------------------- 1 | // OperatorOverloading/Num.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package operatoroverloading 4 | import atomictest.eq 5 | 6 | data class Num(val n: Int) 7 | 8 | operator fun Num.plus(rval: Num) = 9 | Num(n + rval.n) 10 | 11 | fun main() { 12 | Num(4) + Num(5) eq Num(9) 13 | Num(4).plus(Num(5)) eq Num(9) 14 | } 15 | -------------------------------------------------------------------------------- /Examples/OperatorOverloading/StringInvoke.kt: -------------------------------------------------------------------------------- 1 | // OperatorOverloading/StringInvoke.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package operatoroverloading 4 | import atomictest.eq 5 | 6 | operator fun String.invoke( 7 | f: (s: String) -> String 8 | ) = f(this) 9 | 10 | fun main() { 11 | "mumbling" { it.uppercase() } eq 12 | "MUMBLING" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/OperatorOverloading/Swearing.kt: -------------------------------------------------------------------------------- 1 | // OperatorOverloading/Swearing.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package operatoroverloading 4 | import atomictest.eq 5 | 6 | infix fun String.`#!%`(s: String) = 7 | "$this Rowzafrazaca $s" 8 | 9 | fun main() { 10 | "howdy" `#!%` "Ma'am!" eq 11 | "howdy Rowzafrazaca Ma'am!" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Overloading/MemberVsExtension.kt: -------------------------------------------------------------------------------- 1 | // Overloading/MemberVsExtension.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package overloading 4 | import atomictest.eq 5 | 6 | class My { 7 | fun foo() = 0 8 | } 9 | 10 | fun My.foo() = 1 // [1] 11 | 12 | fun My.foo(i: Int) = i + 2 // [2] 13 | 14 | fun main() { 15 | My().foo() eq 0 16 | My().foo(1) eq 3 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Overloading/OverloadedVsDefaultArg.kt: -------------------------------------------------------------------------------- 1 | // Overloading/OverloadedVsDefaultArg.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package overloadingvsdefaultargs 4 | import atomictest.* 5 | 6 | fun foo(n: Int = 99) = trace("foo-1-$n") 7 | 8 | fun foo() { 9 | trace("foo-2") 10 | foo(14) 11 | } 12 | 13 | fun main() { 14 | foo() 15 | trace eq """ 16 | foo-2 17 | foo-1-14 18 | """ 19 | } 20 | -------------------------------------------------------------------------------- /Examples/Overloading/Overloading.kt: -------------------------------------------------------------------------------- 1 | // Overloading/Overloading.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package overloading 4 | import atomictest.eq 5 | 6 | class Overloading { 7 | fun f() = 0 8 | fun f(n: Int) = n + 2 9 | } 10 | 11 | fun main() { 12 | val o = Overloading() 13 | o.f() eq 0 14 | o.f(11) eq 13 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Overloading/Task2.kt: -------------------------------------------------------------------------------- 1 | // Overloading/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package overloadingExercise2 4 | 5 | class Dog { 6 | fun bark(n: Int, say: String = "woof") { 7 | repeat(n) { 8 | println(say) 9 | } 10 | } 11 | } 12 | 13 | fun main() { 14 | /* 15 | val dog = Dog() 16 | dog.bark(3) 17 | dog.bark(2, "wow") 18 | */ 19 | } 20 | /* Expected output: 21 | woof 22 | woof 23 | woof 24 | wow 25 | wow 26 | */ 27 | -------------------------------------------------------------------------------- /Examples/Overloading/Task4.kt: -------------------------------------------------------------------------------- 1 | // Overloading/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package overloadingExercise4 4 | import atomictest.eq 5 | 6 | fun f(n: Int = 0) = n + 373 7 | 8 | fun main() { 9 | f() eq 373 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Overloading/WithDefaultArguments.kt: -------------------------------------------------------------------------------- 1 | // Overloading/WithDefaultArguments.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package withdefaultarguments 4 | import atomictest.eq 5 | 6 | fun f(n: Int = 0) = n + 373 7 | 8 | fun main() { 9 | f() eq 373 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Overloading/WithoutDefaultArguments.kt: -------------------------------------------------------------------------------- 1 | // Overloading/WithoutDefaultArguments.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package withoutdefaultarguments 4 | import atomictest.eq 5 | 6 | fun f(n: Int) = n + 373 7 | fun f() = f(0) 8 | 9 | fun main() { 10 | f() eq 373 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Packages/EquilateralTriangle.kt: -------------------------------------------------------------------------------- 1 | // Packages/EquilateralTriangle.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package pythagorean 4 | import kotlin.math.sqrt 5 | 6 | class EquilateralTriangle(val side: Double) { 7 | fun area() = sqrt(3.0) / 4 * side * side 8 | } 9 | -------------------------------------------------------------------------------- /Examples/Packages/FullyQualify.kt: -------------------------------------------------------------------------------- 1 | // Packages/FullyQualify.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println(kotlin.math.PI) 6 | println(kotlin.math.cos(kotlin.math.PI)) 7 | println(kotlin.math.cos(2 * kotlin.math.PI)) 8 | } 9 | /* Output: 10 | 3.141592653589793 11 | -1.0 12 | 1.0 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/Packages/ImportClass.kt: -------------------------------------------------------------------------------- 1 | // Packages/ImportClass.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import kotlin.math.PI 4 | import kotlin.math.cos // Cosine 5 | 6 | fun main() { 7 | println(PI) 8 | println(cos(PI)) 9 | println(cos(2 * PI)) 10 | } 11 | /* Output: 12 | 3.141592653589793 13 | -1.0 14 | 1.0 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/Packages/ImportEverything.kt: -------------------------------------------------------------------------------- 1 | // Packages/ImportEverything.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import kotlin.math.* 4 | 5 | fun main() { 6 | println(E) 7 | println(E.roundToInt()) 8 | println(E.toInt()) 9 | } 10 | /* Output: 11 | 2.718281828459045 12 | 3 13 | 2 14 | */ 15 | -------------------------------------------------------------------------------- /Examples/Packages/ImportNameChange.kt: -------------------------------------------------------------------------------- 1 | // Packages/ImportNameChange.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import kotlin.math.PI as circleRatio 4 | import kotlin.math.cos as cosine 5 | 6 | fun main() { 7 | println(circleRatio) 8 | println(cosine(circleRatio)) 9 | println(cosine(2 * circleRatio)) 10 | } 11 | /* Output: 12 | 3.141592653589793 13 | -1.0 14 | 1.0 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/Packages/ImportPythagorean.kt: -------------------------------------------------------------------------------- 1 | // Packages/ImportPythagorean.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import pythagorean.RightTriangle 4 | 5 | fun main() { 6 | val rt = RightTriangle(3.0, 4.0) 7 | println(rt.hypotenuse()) 8 | println(rt.area()) 9 | } 10 | /* Output: 11 | 5.0 12 | 6.0 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/Packages/PythagoreanTheorem.kt: -------------------------------------------------------------------------------- 1 | // Packages/PythagoreanTheorem.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package pythagorean 4 | import kotlin.math.sqrt 5 | 6 | class RightTriangle( 7 | val a: Double, 8 | val b: Double 9 | ) { 10 | fun hypotenuse() = sqrt(a * a + b * b) 11 | fun area() = a * b / 2 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Packages/Task1.kt: -------------------------------------------------------------------------------- 1 | // Packages/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package packagesExercise1 4 | import kotlin.math.E 5 | import kotlin.math.PI 6 | 7 | fun main() { 8 | println(PI) 9 | println(E) 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Packages/Task2.kt: -------------------------------------------------------------------------------- 1 | // Packages/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package ccc 4 | import bbb.* 5 | 6 | fun main() { 7 | println(g(1)) 8 | } 9 | -------------------------------------------------------------------------------- /Examples/Packages/Task3.kt: -------------------------------------------------------------------------------- 1 | // Packages/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package packagesExercise3 4 | import pythagorean.EquilateralTriangle 5 | 6 | fun main() { 7 | val et = EquilateralTriangle(1.0) 8 | println(et.area()) // 0.4330127018922193 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Packages/Task4.kt: -------------------------------------------------------------------------------- 1 | // Packages/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package packagesExercise4 4 | 5 | fun main() { 6 | // val t = Isosceles 7 | } 8 | -------------------------------------------------------------------------------- /Examples/Packages/Triangle.kt: -------------------------------------------------------------------------------- 1 | // Packages/Triangle.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package pythagorean 4 | 5 | class IsoscelesRightTriangle( 6 | val side: Double 7 | ) { 8 | fun area() = side * side / 2 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Packages/aaa.kt: -------------------------------------------------------------------------------- 1 | // Packages/aaa.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package aaa 4 | 5 | val x = 10 6 | 7 | fun fa(i: Int) = i * x 8 | 9 | class K { 10 | override fun toString() = "K" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Packages/bbb.kt: -------------------------------------------------------------------------------- 1 | // Packages/bbb.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package bbb 4 | import aaa.* 5 | 6 | fun g(i: Int): String = "${K()} ${fa(i)}" 7 | -------------------------------------------------------------------------------- /Examples/Properties/AnUnchangingVar.kt: -------------------------------------------------------------------------------- 1 | // Properties/AnUnchangingVar.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | class Sofa { 5 | val cover: String = "Loveseat cover" 6 | } 7 | 8 | fun main() { 9 | var sofa = Sofa() 10 | // Not allowed: 11 | // sofa.cover = "New cover" 12 | // Reassigning a var: 13 | sofa = Sofa() 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Properties/Cup.kt: -------------------------------------------------------------------------------- 1 | // Properties/Cup.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | class Cup { 5 | var percentFull = 0 6 | } 7 | 8 | fun main() { 9 | val c1 = Cup() 10 | c1.percentFull = 50 11 | val c2 = Cup() 12 | c2.percentFull = 100 13 | 14 | println(c1.percentFull) 15 | println(c2.percentFull) 16 | } 17 | /* Output: 18 | 50 19 | 100 20 | */ 21 | -------------------------------------------------------------------------------- /Examples/Properties/Task1.kt: -------------------------------------------------------------------------------- 1 | // Properties/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package propertiesExercise1 4 | 5 | class X { 6 | val a = 3 7 | val b = 42 8 | var c: Int = 0 9 | fun add(): Int { 10 | c = a + b 11 | return c 12 | } 13 | } 14 | 15 | fun main() { 16 | val x = X() 17 | println(x.add()) 18 | } 19 | -------------------------------------------------------------------------------- /Examples/Properties/Task4.kt: -------------------------------------------------------------------------------- 1 | // Properties/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package propertiesExercise4 4 | 5 | class Counter { 6 | var value = 0 7 | 8 | fun inc() { 9 | value += 10 10 | } 11 | 12 | fun dec() { 13 | value -= 10 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Properties/TopLevelProperty.kt: -------------------------------------------------------------------------------- 1 | // Properties/TopLevelProperty.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | val constant = 42 5 | 6 | var counter = 0 7 | 8 | fun inc() { 9 | counter++ 10 | } 11 | -------------------------------------------------------------------------------- /Examples/PropertyAccessors/Counter.kt: -------------------------------------------------------------------------------- 1 | // PropertyAccessors/Counter.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package propertyaccessors 4 | import atomictest.eq 5 | 6 | class Counter { 7 | var value: Int = 0 8 | private set 9 | fun inc() = value++ 10 | } 11 | 12 | fun main() { 13 | val counter = Counter() 14 | repeat(10) { 15 | counter.inc() 16 | } 17 | counter.value eq 10 18 | } 19 | -------------------------------------------------------------------------------- /Examples/PropertyAccessors/Data.kt: -------------------------------------------------------------------------------- 1 | // PropertyAccessors/Data.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package propertyaccessors 4 | import atomictest.eq 5 | 6 | class Data(var i: Int) 7 | 8 | fun main() { 9 | val data = Data(10) 10 | data.i eq 10 // Read the 'i' property 11 | data.i = 20 // Write to the 'i' property 12 | } 13 | -------------------------------------------------------------------------------- /Examples/PropertyAccessors/Hamsters2.kt: -------------------------------------------------------------------------------- 1 | // PropertyAccessors/Hamsters2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package propertyaccessors 4 | 5 | class Cage2(private val maxCapacity: Int) { 6 | private val hamsters = 7 | mutableListOf() 8 | fun capacity(): Int = 9 | maxCapacity - hamsters.size 10 | fun isFull(): Boolean = 11 | hamsters.size == maxCapacity 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Recursion/CallStack.kt: -------------------------------------------------------------------------------- 1 | // Recursion/CallStack.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package recursion 4 | 5 | fun illegalState() { 6 | // throw IllegalStateException() 7 | } 8 | 9 | fun fail() = illegalState() 10 | 11 | fun main() { 12 | fail() 13 | } 14 | -------------------------------------------------------------------------------- /Examples/Recursion/Factorial.kt: -------------------------------------------------------------------------------- 1 | // Recursion/Factorial.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package recursion 4 | import atomictest.eq 5 | 6 | fun factorial(n: Long): Long { 7 | if (n <= 1) return 1 8 | return n * factorial(n - 1) 9 | } 10 | 11 | fun main() { 12 | factorial(5) eq 120 13 | factorial(17) eq 355687428096000 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Recursion/InfiniteRecursion.kt: -------------------------------------------------------------------------------- 1 | // Recursion/InfiniteRecursion.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package recursion 4 | 5 | fun recurse(i: Int): Int = recurse(i + 1) 6 | 7 | fun main() { 8 | // println(recurse(1)) 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Recursion/Iteration.kt: -------------------------------------------------------------------------------- 1 | // Recursion/Iteration.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package iteration 4 | import atomictest.eq 5 | 6 | fun sum(n: Long): Long { 7 | var accumulator = 0L 8 | for (i in 1..n) { 9 | accumulator += i 10 | } 11 | return accumulator 12 | } 13 | 14 | fun main() { 15 | sum(10000) eq 50005000 16 | sum(100000) eq 5000050000 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Recursion/RecursionLimits.kt: -------------------------------------------------------------------------------- 1 | // Recursion/RecursionLimits.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package recursion 4 | import atomictest.eq 5 | 6 | fun sum(n: Long): Long { 7 | if (n == 0L) return 0 8 | return n + sum(n - 1) 9 | } 10 | 11 | fun main() { 12 | sum(2) eq 3 13 | sum(1000) eq 500500 14 | // sum(100_000) eq 500050000 // [1] 15 | (1..100_000L).sum() eq 5000050000 // [2] 16 | } 17 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/AssignmentOperators.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/AssignmentOperators.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var n = 10 6 | val d = 3 7 | print(n) 8 | while (n > d) { 9 | n -= d 10 | print(" - $d") 11 | } 12 | println(" = $n") 13 | 14 | var m = 10 15 | print(m) 16 | m %= d 17 | println(" % $d = $m") 18 | } 19 | /* Output: 20 | 10 - 3 - 3 - 3 = 1 21 | 10 % 3 = 1 22 | */ 23 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/DoWhileLoop.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/DoWhileLoop.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var i = 0 6 | do { 7 | print(".") 8 | i += 10 9 | } while (condition(i)) 10 | } 11 | /* Output: 12 | .......... 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/IncrementOperator.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/IncrementOperator.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var i = 0 6 | while (i < 4) { 7 | print(".") 8 | i++ 9 | } 10 | } 11 | /* Output: 12 | .... 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/Task1.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package repetitionWithWhileExercise1 4 | 5 | fun displayContent(s: String) { 6 | var i = 0 7 | while (i < s.length) { 8 | println(s[i]) 9 | i++ 10 | } 11 | } 12 | 13 | fun main() { 14 | // displayContent("abc") 15 | } 16 | /* Expected output: 17 | a 18 | b 19 | c 20 | */ 21 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/Task2.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package repetitionWithWhileExercise2 4 | 5 | fun sum(number: Int): Int { 6 | var sum = 0 7 | var i = 0 8 | while (i <= number) { 9 | sum += i 10 | i++ 11 | } 12 | return sum 13 | } 14 | 15 | fun main() { 16 | println(sum(10)) // 55 17 | } 18 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/Task3.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package repetitionWithWhileExercise3 4 | 5 | fun sumOfEven(n: Int): Int { 6 | var result = 0 7 | var i = 0 8 | while (i <= n) { 9 | if (i % 2 == 0) { 10 | result += i 11 | } 12 | i++ 13 | } 14 | return result 15 | } 16 | 17 | fun main() { 18 | println(sumOfEven(10)) // 30 19 | } 20 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/Task4.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package repetitionWithWhileExercise4 4 | 5 | fun getFooResult(): Int = 736 6 | 7 | fun main() { 8 | println("Foo result is: ${getFooResult()}") 9 | } 10 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/Task5.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package repetitionWithWhileExercise5 4 | 5 | fun getFooResult(): Int = 736 6 | 7 | fun main() { 8 | println("Foo result is: ${getFooResult()}") 9 | } 10 | -------------------------------------------------------------------------------- /Examples/RepetitionWithWhile/WhileLoop.kt: -------------------------------------------------------------------------------- 1 | // RepetitionWithWhile/WhileLoop.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun condition(i: Int) = i < 100 // [1] 5 | 6 | fun main() { 7 | var i = 0 8 | while (condition(i)) { // [2] 9 | print(".") 10 | i += 10 // [3] 11 | } 12 | } 13 | /* Output: 14 | .......... 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/ResourceCleanup/AutoCloseable.kt: -------------------------------------------------------------------------------- 1 | // ResourceCleanup/AutoCloseable.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | import checkinstructions.DataFile 5 | 6 | fun main() { 7 | DataFile("Results.txt") 8 | .bufferedReader() 9 | .use { it.readLines().first() } eq 10 | "Results" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/ResourceCleanup/ForEachLine.kt: -------------------------------------------------------------------------------- 1 | // ResourceCleanup/ForEachLine.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import checkinstructions.DataFile 4 | import atomictest.* 5 | 6 | fun main() { 7 | DataFile("Results.txt").forEachLine { 8 | if (it.startsWith("#")) 9 | trace("$it") 10 | } 11 | trace eq "# ok" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ResourceCleanup/Usable.kt: -------------------------------------------------------------------------------- 1 | // ResourceCleanup/Usable.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package resourcecleanup 4 | import atomictest.* 5 | 6 | class Usable() : AutoCloseable { 7 | fun func() = trace("func()") 8 | override fun close() = trace("close()") 9 | } 10 | 11 | fun main() { 12 | Usable().use { it.func() } 13 | trace eq "func() close()" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/SafeCallsAndElvis/DereferenceNull.kt: -------------------------------------------------------------------------------- 1 | // SafeCallsAndElvis/DereferenceNull.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val s: String? = null 6 | // Doesn't compile: 7 | // s.length // [1] 8 | } 9 | -------------------------------------------------------------------------------- /Examples/SafeCallsAndElvis/ElvisOperator.kt: -------------------------------------------------------------------------------- 1 | // SafeCallsAndElvis/ElvisOperator.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val s1: String? = "abc" 7 | (s1 ?: "---") eq "abc" 8 | 9 | val s2: String? = null 10 | (s2 ?: "---") eq "---" 11 | } 12 | -------------------------------------------------------------------------------- /Examples/SafeCallsAndElvis/Task1.kt: -------------------------------------------------------------------------------- 1 | // SafeCallsAndElvis/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package safeCallsAndTheElvisOperatorExercise1 4 | import atomictest.eq 5 | 6 | fun downcase(s: String?): String = 7 | s?.lowercase() ?: "" 8 | 9 | fun main() { 10 | downcase(null) eq "" 11 | downcase("ABC") eq "abc" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/ScopeFunctions/AndNullability.kt: -------------------------------------------------------------------------------- 1 | // ScopeFunctions/AndNullability.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package scopefunctions 4 | import atomictest.eq 5 | import kotlin.random.Random 6 | 7 | fun gets(): String? = 8 | if (Random.nextBoolean()) "str!" else null 9 | 10 | fun main() { 11 | gets()?.let { 12 | it.removeSuffix("!") + it.length 13 | }?.eq("str4") 14 | } 15 | -------------------------------------------------------------------------------- /Examples/SealedClasses/SealedEx2.kt: -------------------------------------------------------------------------------- 1 | // SealedClasses/SealedEx2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sealedClassesExercise2 4 | import sealedClassesExercise1.* 5 | import atomictest.* 6 | 7 | fun main() { 8 | Transport::class.sealedSubclasses 9 | .map { it.simpleName } 10 | .forEach { trace(it) } 11 | trace eq """ 12 | Train 13 | Bus 14 | Tram 15 | Plane 16 | """ 17 | } 18 | -------------------------------------------------------------------------------- /Examples/SealedClasses/SealedSubclasses.kt: -------------------------------------------------------------------------------- 1 | // SealedClasses/SealedSubclasses.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sealedclasses 4 | import atomictest.eq 5 | 6 | sealed class Top 7 | class Middle1 : Top() 8 | class Middle2 : Top() 9 | open class Middle3 : Top() 10 | class Bottom3 : Middle3() 11 | 12 | fun main() { 13 | Top::class.sealedSubclasses 14 | .map { it.simpleName } eq 15 | "[Middle1, Middle2, Middle3]" 16 | } 17 | -------------------------------------------------------------------------------- /Examples/SealedClasses/ThirdLevelSealed.kt: -------------------------------------------------------------------------------- 1 | // SealedClasses/ThirdLevelSealed.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sealedclasses 4 | 5 | class ThirdLevel : SealedSubclass() 6 | -------------------------------------------------------------------------------- /Examples/SecondaryConstructors/Task1.kt: -------------------------------------------------------------------------------- 1 | // SecondaryConstructors/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package secondaryConstructorsExercise1 4 | import atomictest.eq 5 | 6 | data class Flower1(val type: String) { 7 | constructor(): this("Daisy") 8 | } 9 | 10 | data class Flower2(val type: String = "Daisy") 11 | 12 | fun main() { 13 | Flower1().type eq "Daisy" 14 | Flower2().type eq "Daisy" 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Sequences/DefineTakeIf.kt: -------------------------------------------------------------------------------- 1 | // Sequences/DefineTakeIf.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sequences 4 | import atomictest.eq 5 | 6 | fun T.takeIf( 7 | predicate: (T) -> Boolean 8 | ): T? { 9 | return if (predicate(this)) this else null 10 | } 11 | 12 | fun main() { 13 | "abc".takeIf { it != "XXX" } eq "abc" 14 | "XXX".takeIf { it != "XXX" } eq null 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Sequences/GenerateSequence1.kt: -------------------------------------------------------------------------------- 1 | // Sequences/GenerateSequence1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val naturalNumbers = 7 | generateSequence(1) { it + 1 } 8 | naturalNumbers.take(3).toList() eq 9 | listOf(1, 2, 3) 10 | naturalNumbers.take(10).sum() eq 55 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Sequences/NoComputationYet.kt: -------------------------------------------------------------------------------- 1 | // Sequences/NoComputationYet.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | import sequences.* 5 | 6 | fun main() { 7 | val r = listOf(1, 2, 3, 4) 8 | .asSequence() 9 | .filter(Int::isEven) 10 | .map(Int::square) 11 | r.toString().substringBefore("@") eq 12 | "kotlin.sequences.TransformingSequence" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/Sequences/NumberSequence2.kt: -------------------------------------------------------------------------------- 1 | // Sequences/NumberSequence2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | generateSequence(6) { 7 | (it - 1).takeIf { it > 0 } 8 | }.toList() eq listOf(6, 5, 4, 3, 2, 1) 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Sequences/Task1.kt: -------------------------------------------------------------------------------- 1 | // Sequences/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sequencesExercise1 4 | 5 | fun School.commonLessons( 6 | instructor: Instructor, 7 | student: Student 8 | ): Sequence { 9 | return lessons.filter { 10 | instructor == it.instructor && student in it.students 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Sequences/Task3.kt: -------------------------------------------------------------------------------- 1 | // Sequences/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sequencesExercise3 4 | 5 | fun School.averageInstructorRating(instructor: Instructor): Double = 6 | lessons 7 | .filter { it.instructor == instructor } 8 | .flatMap { it.rating.values.asSequence() } 9 | .average() 10 | -------------------------------------------------------------------------------- /Examples/Sequences/Task4.kt: -------------------------------------------------------------------------------- 1 | // Sequences/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sequencesExercise4 4 | 5 | fun School.favoriteInstructor(student: Student): Instructor? = 6 | lessons 7 | .filter { student in it.students } 8 | .groupBy { it.instructor } 9 | .maxByOrNull { (_, lessons) -> lessons.size } 10 | ?.key 11 | -------------------------------------------------------------------------------- /Examples/Sequences/Task5.kt: -------------------------------------------------------------------------------- 1 | // Sequences/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sequencesExercise5 4 | 5 | fun School.instructorsWithLargestClass(): Set { 6 | val maxClassSize = lessons 7 | .map { it.students.size } 8 | .maxOrNull() 9 | 10 | return lessons.filter { it.students.size == maxClassSize } 11 | .map { it.instructor } 12 | .toSet() 13 | } 14 | -------------------------------------------------------------------------------- /Examples/Sequences/Task6.kt: -------------------------------------------------------------------------------- 1 | // Sequences/Task6.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sequencesExercise6 4 | import atomictest.eq 5 | 6 | fun from(n: Int): Sequence = generateSequence(n) { it + 1 } 7 | 8 | fun main() { 9 | from(10).take(2).toList() eq listOf(10, 11) 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Sequences/Task7.kt: -------------------------------------------------------------------------------- 1 | // Sequences/Task7.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package sequencesExercise7 4 | 5 | fun oddWithoutDigitOne(): Sequence { 6 | return generateSequence(3) { it + 2 } 7 | .filter { '1' !in it.toString() } 8 | } 9 | 10 | fun main() { 11 | println(oddWithoutDigitOne().take(20).sum()) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Sets/MutableSet.kt: -------------------------------------------------------------------------------- 1 | // Sets/MutableSet.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val mutableSet = mutableSetOf() 7 | mutableSet += 42 8 | mutableSet += 42 9 | mutableSet eq setOf(42) 10 | mutableSet -= 42 11 | mutableSet eq setOf() 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Sets/RemoveDuplicates.kt: -------------------------------------------------------------------------------- 1 | // Sets/RemoveDuplicates.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(3, 3, 2, 1, 2) 7 | list.toSet() eq setOf(1, 2, 3) 8 | list.distinct() eq listOf(3, 2, 1) 9 | "abbcc".toSet() eq setOf('a', 'b', 'c') 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Sets/Task1.kt: -------------------------------------------------------------------------------- 1 | // Sets/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package setsExercise1 4 | import atomictest.eq 5 | 6 | fun hasUniqueCharacters(s: String): Boolean { 7 | return s.toSet().size == s.length 8 | } 9 | 10 | fun main() { 11 | hasUniqueCharacters("abcd") eq true 12 | hasUniqueCharacters("abcb") eq false 13 | } 14 | -------------------------------------------------------------------------------- /Examples/Sets/Task4.kt: -------------------------------------------------------------------------------- 1 | // Sets/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package setsExercise4 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3, 4) 7 | println(list) 8 | } 9 | -------------------------------------------------------------------------------- /Examples/StringTemplates/ExpressionInTemplate.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/ExpressionInTemplate.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val condition = true 6 | println( 7 | "${if (condition) 'a' else 'b'}") // [1] 8 | val x = 11 9 | println("$x + 4 = ${x + 4}") 10 | } 11 | /* Output: 12 | a 13 | 11 + 4 = 15 14 | */ 15 | -------------------------------------------------------------------------------- /Examples/StringTemplates/StringConcatenation.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/StringConcatenation.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val s = "hi\n" // \n is a newline character 6 | val n = 11 7 | val d = 3.14 8 | println("first: " + s + "second: " + 9 | n + ", third: " + d) 10 | } 11 | /* Output: 12 | first: hi 13 | second: 11, third: 3.14 14 | */ 15 | -------------------------------------------------------------------------------- /Examples/StringTemplates/StringTemplates.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/StringTemplates.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val answer = 42 6 | println("Found $answer!") // [1] 7 | println("printing a $1") // [2] 8 | } 9 | /* Output: 10 | Found 42! 11 | printing a $1 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/StringTemplates/Task1.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package stringTemplatesExercise1 4 | 5 | fun findMax(first: Int, second: Int): Int = 6 | if (first > second) first else second 7 | 8 | fun main() { 9 | val first = 17 10 | val second = 31 11 | println("The maximum of $first and $second is " + 12 | "${findMax(first, second)}.") 13 | } 14 | -------------------------------------------------------------------------------- /Examples/StringTemplates/Task3.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package stringTemplatesExercise3 4 | 5 | fun show(i: Int, s: String, c: Char, d: Double) { 6 | println("i: $i") 7 | println("""s: "$s"""") 8 | println("c: '$c'") 9 | println("d: $d") 10 | } 11 | 12 | fun main() { 13 | // show(1, "abc", 'd', 2.0) 14 | } 15 | /* Expected output: 16 | i: 1 17 | s: "abc" 18 | c: 'd' 19 | d: 2.0 20 | */ 21 | -------------------------------------------------------------------------------- /Examples/StringTemplates/Task4.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package stringTemplatesExercise4 4 | 5 | // foo 6 | fun foo() = 1 7 | 8 | fun main() { 9 | println(foo()) 10 | } 11 | -------------------------------------------------------------------------------- /Examples/StringTemplates/Task5.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package stringTemplatesExercise5 4 | 5 | fun main() { 6 | val answer = 42 7 | println("The answer is $answer") 8 | } 9 | -------------------------------------------------------------------------------- /Examples/StringTemplates/TripleQuotes.kt: -------------------------------------------------------------------------------- 1 | // StringTemplates/TripleQuotes.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val s = "value" 6 | println("s = \"$s\".") 7 | println("""s = "$s".""") 8 | } 9 | /* Output: 10 | s = "value". 11 | s = "value". 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/Summary1/BasicFunctions.kt: -------------------------------------------------------------------------------- 1 | // Summary1/BasicFunctions.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun cube(x: Int): Int { 5 | return x * x * x 6 | } 7 | 8 | fun bang(s: String) = s + "!" 9 | 10 | fun main() { 11 | println(cube(3)) 12 | println(bang("pop")) 13 | } 14 | /* Output: 15 | 27 16 | pop! 17 | */ 18 | -------------------------------------------------------------------------------- /Examples/Summary1/DoWhile.kt: -------------------------------------------------------------------------------- 1 | // Summary1/DoWhile.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var i = 0 6 | do { 7 | print(".") 8 | i += 10 9 | } while (testCondition(i)) 10 | } 11 | /* Output: 12 | .......... 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/Summary1/Hello.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Hello.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println("Hello, world!") 6 | } 7 | /* Output: 8 | Hello, world! 9 | */ 10 | -------------------------------------------------------------------------------- /Examples/Summary1/IfResult.kt: -------------------------------------------------------------------------------- 1 | // Summary1/IfResult.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val result = if (99 < 100) 4 else 42 6 | println(result) 7 | } 8 | /* Output: 9 | 4 10 | */ 11 | -------------------------------------------------------------------------------- /Examples/Summary1/NumberTypes.kt: -------------------------------------------------------------------------------- 1 | // Summary1/NumberTypes.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val n = 1000 // Int 6 | val l = 1000L // Long 7 | val d = 1000.0 // Double 8 | println("$n $l $d") 9 | } 10 | /* Output: 11 | 1000 1000 1000.0 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/Summary1/Overflow.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Overflow.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | println(Int.MAX_VALUE + 1) 6 | println(Int.MAX_VALUE + 1L) 7 | } 8 | /* Output: 9 | -2147483648 10 | 2147483648 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/Summary1/RangeOfInt.kt: -------------------------------------------------------------------------------- 1 | // Summary1/RangeOfInt.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | for (i in 1..10) { 6 | print("$i ") 7 | } 8 | } 9 | /* Output: 10 | 1 2 3 4 5 6 7 8 9 10 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/Summary1/StrTemplates.kt: -------------------------------------------------------------------------------- 1 | // Summary1/StrTemplates.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val answer = 42 6 | println("Found $answer!") // [1] 7 | val condition = true 8 | println( 9 | "${if (condition) 'a' else 'b'}") // [2] 10 | println("printing a $1") // [3] 11 | } 12 | /* Output: 13 | Found 42! 14 | a 15 | printing a $1 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/Summary1/StringIteration.kt: -------------------------------------------------------------------------------- 1 | // Summary1/StringIteration.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | for (c in "Kotlin") { 6 | print("$c ") 7 | // c += 1 // error: 8 | // val cannot be reassigned 9 | } 10 | } 11 | /* Output: 12 | K o t l i n 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/Summary1/Task1.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIExercise1 4 | 5 | fun main() { 6 | var x = 1 7 | val y = x 8 | val z = y 9 | x = 2 10 | println(x) 11 | println(y) 12 | println(z) 13 | } 14 | -------------------------------------------------------------------------------- /Examples/Summary1/Task2.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIExercise2 4 | 5 | fun other(s: String): String { 6 | var index = 0 7 | var result = "" 8 | for (c in s) { 9 | if (index % 2 == 0) { 10 | result += c 11 | } 12 | index++ 13 | } 14 | return result 15 | } 16 | 17 | fun main() { 18 | println(other("cement")) 19 | } 20 | /* Output: 21 | cmn 22 | */ 23 | -------------------------------------------------------------------------------- /Examples/Summary1/Task5.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIExercise5 4 | 5 | fun everyFifth(start: Int, end: Int) { 6 | for (i in start..end) { 7 | if ((i - start) % 5 == 4) { 8 | println(i) 9 | } 10 | } 11 | } 12 | 13 | fun main() { 14 | everyFifth(11, 30) 15 | } 16 | /* Output: 17 | 15 18 | 20 19 | 25 20 | 30 21 | */ 22 | -------------------------------------------------------------------------------- /Examples/Summary1/Task6.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Task6.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIExercise6 4 | 5 | fun everyFifthNonSpace(s: String) { 6 | var i = 1 7 | for (c in s) { 8 | if (i % 5 == 0 && c != ' ') { 9 | println(c) 10 | } 11 | if (c != ' ') i++ 12 | } 13 | } 14 | 15 | fun main() { 16 | everyFifthNonSpace("abc d e fgh ik") 17 | } 18 | /* Output: 19 | e 20 | k 21 | */ 22 | -------------------------------------------------------------------------------- /Examples/Summary1/Task8.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Task8.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIExercise8 4 | 5 | fun reverseDecimal(number: Int): Int { 6 | var worker = number 7 | var result = 0 8 | 9 | while (worker > 0) { 10 | result *= 10 11 | result += worker % 10 12 | worker /= 10 13 | } 14 | return result 15 | } 16 | 17 | fun main() { 18 | println(reverseDecimal(1234)) // 4321 19 | } 20 | -------------------------------------------------------------------------------- /Examples/Summary1/Task9.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Task9.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIExercise9 4 | 5 | fun printTriangle(n: Int) { 6 | for (i in 1..n) { 7 | repeat(n - i) { 8 | print(' ') 9 | } 10 | repeat(2 * i - 1) { 11 | print('#') 12 | } 13 | println() 14 | } 15 | } 16 | 17 | fun main() { 18 | printTriangle(4) 19 | } 20 | /* Output: 21 | # 22 | ### 23 | ##### 24 | ####### 25 | */ 26 | -------------------------------------------------------------------------------- /Examples/Summary1/ThreeQuotes.kt: -------------------------------------------------------------------------------- 1 | // Summary1/ThreeQuotes.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun json(q: String, a: Int) = """{ 5 | "question" : "$q", 6 | "answer" : $a 7 | }""" 8 | 9 | fun main() { 10 | println(json("The Ultimate", 42)) 11 | } 12 | /* Output: 13 | { 14 | "question" : "The Ultimate", 15 | "answer" : 42 16 | } 17 | */ 18 | -------------------------------------------------------------------------------- /Examples/Summary1/Truncation.kt: -------------------------------------------------------------------------------- 1 | // Summary1/Truncation.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val d1: Double = 3.0 + 2 / 5 6 | println(d1) 7 | val d2: Double = 3 + 2.0 / 5 8 | println(d2) 9 | } 10 | /* Output: 11 | 3.0 12 | 3.4 13 | */ 14 | -------------------------------------------------------------------------------- /Examples/Summary1/UnitReturn.kt: -------------------------------------------------------------------------------- 1 | // Summary1/UnitReturn.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val result = println("returns Unit") 6 | println(result) 7 | } 8 | /* Output: 9 | returns Unit 10 | kotlin.Unit 11 | */ 12 | -------------------------------------------------------------------------------- /Examples/Summary1/While.kt: -------------------------------------------------------------------------------- 1 | // Summary1/While.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun testCondition(i: Int) = i < 100 5 | 6 | fun main() { 7 | var i = 0 8 | while (testCondition(i)) { 9 | print(".") 10 | i += 10 11 | } 12 | } 13 | /* Output: 14 | .......... 15 | */ 16 | -------------------------------------------------------------------------------- /Examples/Summary2/ALibrary.kt: -------------------------------------------------------------------------------- 1 | // Summary2/ALibrary.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package com.yoururl.libraryname 4 | 5 | // Components to reuse ... 6 | fun f() = "result" 7 | -------------------------------------------------------------------------------- /Examples/Summary2/ArraySpread.kt: -------------------------------------------------------------------------------- 1 | // Summary2/ArraySpread.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import summary2.varargs 4 | import atomictest.trace 5 | 6 | fun main() { 7 | val array = intArrayOf(4, 5) // [1] 8 | varargs("x", 1, 2, 3, *array, 6) // [2] 9 | val list = listOf(9, 10, 11) 10 | varargs( 11 | "y", 7, 8, *list.toIntArray()) // [3] 12 | trace eq "1 2 3 4 5 6 x 7 8 9 10 11 y" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/Summary2/AtomicTestCapture.kt: -------------------------------------------------------------------------------- 1 | // Summary2/AtomicTestCapture.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | capture { 7 | "$1.9".toDouble() 8 | } eq "NumberFormatException: " + 9 | """For input string: "$1.9"""" 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Summary2/ClassBodies.kt: -------------------------------------------------------------------------------- 1 | // Summary2/ClassBodies.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summary2 4 | 5 | class NoBody 6 | 7 | class SomeBody { 8 | val name = "Janet Doe" 9 | } 10 | 11 | class EveryBody { 12 | val all = listOf(SomeBody(), 13 | SomeBody(), SomeBody()) 14 | } 15 | 16 | fun main() { 17 | val nb = NoBody() 18 | val sb = SomeBody() 19 | val eb = EveryBody() 20 | } 21 | -------------------------------------------------------------------------------- /Examples/Summary2/ListCollection.kt: -------------------------------------------------------------------------------- 1 | // Summary2/ListCollection.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val lst = listOf(19.2, 88.3, 22.1) 7 | lst[1] eq 88.3 // Indexing 8 | lst.reversed() eq listOf(22.1, 88.3, 19.2) 9 | lst.sorted() eq listOf(19.2, 22.1, 88.3) 10 | lst.sum() eq 129.6 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Summary2/MultipleListReferences.kt: -------------------------------------------------------------------------------- 1 | // Summary2/MultipleListReferences.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val first = mutableListOf(1) 7 | val second: List = first 8 | second eq listOf(1) 9 | first += 2 10 | // second sees the change: 11 | second eq listOf(1, 2) 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Summary2/PropertyReadWrite.kt: -------------------------------------------------------------------------------- 1 | // Summary2/PropertyReadWrite.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summary2 4 | import atomictest.eq 5 | 6 | class Holder(var i: Int) 7 | 8 | fun main() { 9 | val holder = Holder(10) 10 | holder.i eq 10 // Read the 'i' property 11 | holder.i = 20 // Write to the 'i' property 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Summary2/Task1.kt: -------------------------------------------------------------------------------- 1 | // Summary2/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIIExercise1 4 | import atomictest.eq 5 | 6 | class Boring { 7 | fun a() = 1.618 8 | fun b() = "ratio" 9 | fun c() = 11 10 | } 11 | 12 | fun main() { 13 | val boring = Boring() 14 | boring.a() eq 1.618 15 | boring.b() eq "ratio" 16 | boring.c() eq 11 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Summary2/Task2.kt: -------------------------------------------------------------------------------- 1 | // Summary2/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summaryIIExercise2 4 | import atomictest.eq 5 | 6 | class Boring2(val a: Double, val b: String, val c: Int) { 7 | fun a() = a 8 | fun b() = b 9 | fun c() = c 10 | } 11 | 12 | fun main() { 13 | val boring2 = Boring2(1.0, "abc", 3) 14 | boring2.a() eq 1.0 15 | boring2.b() eq "abc" 16 | boring2.c() eq 3 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Summary2/Task4.kt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/Examples/Summary2/Task4.kt -------------------------------------------------------------------------------- /Examples/Summary2/ToDoubleException.kt: -------------------------------------------------------------------------------- 1 | // Summary2/ToDoubleException.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | // val i = "$1.9".toDouble() 6 | } 7 | -------------------------------------------------------------------------------- /Examples/Summary2/UseALibrary.kt: -------------------------------------------------------------------------------- 1 | // Summary2/UseALibrary.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import com.yoururl.libraryname.* 4 | 5 | fun main() { 6 | val x = f() 7 | } 8 | -------------------------------------------------------------------------------- /Examples/Summary2/UsingAtomicTest.kt: -------------------------------------------------------------------------------- 1 | // Summary2/UsingAtomicTest.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | val pi = 3.14 7 | val pie = "A round dessert" 8 | pi eq 3.14 9 | pie eq "A round dessert" 10 | pi neq pie 11 | } 12 | /* Output: 13 | 3.14 14 | A round dessert 15 | 3.14 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/Summary2/VarArgs.kt: -------------------------------------------------------------------------------- 1 | // Summary2/VarArgs.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package summary2 4 | import atomictest.* 5 | 6 | fun varargs(s: String, vararg ints: Int) { 7 | for (i in ints) { 8 | trace("$i") 9 | } 10 | trace(s) 11 | } 12 | 13 | fun main() { 14 | varargs("primes", 5, 7, 11, 13, 17, 19, 23) 15 | trace eq "5 7 11 13 17 19 23 primes" 16 | } 17 | -------------------------------------------------------------------------------- /Examples/Testing/TDDFail.kt: -------------------------------------------------------------------------------- 1 | // Testing/TDDFail.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package testing1 4 | import atomictest.eq 5 | 6 | fun main() { 7 | calculateBMI(160, 68) eq "Normal weight" 8 | // calculateBMI(100, 68) eq "Underweight" 9 | // calculateBMI(200, 68) eq "Overweight" 10 | } 11 | 12 | fun calculateBMI(lbs: Int, height: Int) = 13 | "Normal weight" 14 | -------------------------------------------------------------------------------- /Examples/Testing/Task1.kt: -------------------------------------------------------------------------------- 1 | // Testing/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package testingExercise1 4 | import atomictest.eq 5 | 6 | fun abs(number: Int): Int = if (number > 0) number else -number 7 | 8 | fun main() { 9 | abs(0) eq 0 10 | abs(42) eq 42 11 | abs(-239) eq 239 12 | } 13 | -------------------------------------------------------------------------------- /Examples/Testing/Task2.kt: -------------------------------------------------------------------------------- 1 | // Testing/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package testingExercise2 4 | import atomictest.eq 5 | import atomictest.neq 6 | 7 | fun sum(a: Int, b: Int, c: Int): Int = a + b + c 8 | 9 | fun main() { 10 | sum(1, 1, 1) eq 3 11 | sum(1, 2, 3) eq 6 12 | sum(1, 2, 3) neq 5 13 | sum(-1, -10, -100) eq -111 14 | sum(2131, 81783, 16085) eq 99999 15 | } 16 | -------------------------------------------------------------------------------- /Examples/Testing/Task4.kt: -------------------------------------------------------------------------------- 1 | // Testing/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package testingExercise4 4 | 5 | fun main() { 6 | // println("Uncomment me") 7 | println("Comment me") 8 | } 9 | -------------------------------------------------------------------------------- /Examples/Testing/Trace1.kt: -------------------------------------------------------------------------------- 1 | // Testing/Trace1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | trace("line 1") 7 | trace(47) 8 | trace("line 2") 9 | trace eq """ 10 | line 1 11 | 47 12 | line 2 13 | """ 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Testing/UsingTrace.kt: -------------------------------------------------------------------------------- 1 | // Testing/UsingTrace.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.* 4 | 5 | fun main() { 6 | trace("Hello,") 7 | trace(47) 8 | trace("World!") 9 | trace eq """ 10 | Hello, 11 | 47 12 | World! 13 | """ 14 | } 15 | -------------------------------------------------------------------------------- /Examples/TypeChecking/AnyName.kt: -------------------------------------------------------------------------------- 1 | // TypeChecking/AnyName.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package typechecking 4 | 5 | val Any.name 6 | get() = this::class.simpleName 7 | -------------------------------------------------------------------------------- /Examples/UnitTesting/Learner.kt: -------------------------------------------------------------------------------- 1 | // UnitTesting/Learner.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package unittesting 4 | 5 | enum class Language { 6 | Kotlin, Java, Go, Python, Rust, Scala 7 | } 8 | 9 | data class Learner( 10 | val id: Int, 11 | val name: String, 12 | val surname: String, 13 | val language: Language 14 | ) 15 | -------------------------------------------------------------------------------- /Examples/Upcasting/Assignment.kt: -------------------------------------------------------------------------------- 1 | // Upcasting/Assignment.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import upcasting.* 4 | 5 | fun main() { 6 | val shape1: Shape = Square() 7 | val shape2: Shape = Triangle() 8 | // Doesn't compile: 9 | // shape1.color() 10 | // shape2.rotate() 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Upcasting/Drawing.kt: -------------------------------------------------------------------------------- 1 | // Upcasting/Drawing.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package upcasting 4 | import atomictest.* 5 | 6 | fun show(shape: Shape) { 7 | trace("Show: ${shape.draw()}") 8 | } 9 | 10 | fun main() { 11 | listOf(Circle(), Square(), Triangle()) 12 | .forEach(::show) 13 | trace eq """ 14 | Show: Circle.draw 15 | Show: Square.draw 16 | Show: Triangle.draw 17 | """ 18 | } 19 | -------------------------------------------------------------------------------- /Examples/UsingOperators/ComparableRange.kt: -------------------------------------------------------------------------------- 1 | // UsingOperators/ComparableRange.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package usingoperators 4 | import atomictest.eq 5 | 6 | class F(val i: Int): Comparable { 7 | override fun compareTo(other: F) = 8 | i.compareTo(other.i) 9 | } 10 | 11 | fun main() { 12 | val range = F(1)..F(7) 13 | (F(3) in range) eq true 14 | (F(9) in range) eq false 15 | } 16 | -------------------------------------------------------------------------------- /Examples/UsingOperators/ReadOnlyAndPlus.kt: -------------------------------------------------------------------------------- 1 | // UsingOperators/ReadOnlyAndPlus.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | var list = listOf(1, 2) 7 | val initial = list 8 | list += 3 9 | list eq "[1, 2, 3]" 10 | list = list.plus(4) 11 | list eq "[1, 2, 3, 4]" 12 | initial eq "[1, 2]" 13 | } 14 | -------------------------------------------------------------------------------- /Examples/UsingOperators/Unexpected.kt: -------------------------------------------------------------------------------- 1 | // UsingOperators/Unexpected.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | var list = listOf(1, 2) 7 | list += 3 // Probably unexpected 8 | list eq "[1, 2, 3]" 9 | } 10 | -------------------------------------------------------------------------------- /Examples/VarAndVal/AVarIsMutable.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/AVarIsMutable.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var sum = 1 6 | sum = sum + 2 7 | sum += 3 8 | println(sum) 9 | } 10 | /* Output: 11 | 6 12 | */ 13 | -------------------------------------------------------------------------------- /Examples/VarAndVal/Task1.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varAndValExercise1 4 | 5 | fun main() { 6 | var answer = 42 7 | println(answer) 8 | answer = 43 9 | println(answer) 10 | } 11 | -------------------------------------------------------------------------------- /Examples/VarAndVal/Task2.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varAndValExercise2 4 | 5 | fun main() { 6 | var a = 10 7 | val b = a 8 | a = 42 9 | println(a) 10 | println(b) 11 | } 12 | -------------------------------------------------------------------------------- /Examples/VarAndVal/Task3.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/Task3.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varAndValExercise3 4 | 5 | fun main() { 6 | var x = 1 7 | var y = 2 8 | val tmp = x 9 | x = y 10 | y = tmp 11 | println(x) 12 | println(y) 13 | } 14 | -------------------------------------------------------------------------------- /Examples/VarAndVal/Task4.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varAndValExercise4 4 | 5 | fun main() { 6 | println("Hello, Kotlin!") 7 | } 8 | -------------------------------------------------------------------------------- /Examples/VarAndVal/Task5.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varAndValExercise5 4 | 5 | fun main() { 6 | println("Hello, Kotlin!") 7 | } 8 | -------------------------------------------------------------------------------- /Examples/VarAndVal/Vals.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/Vals.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | val whole = 11 6 | // whole = 15 // Error // [1] 7 | val fractional = 1.4 8 | val words = "Twas Brillig" 9 | println(whole) 10 | println(fractional) 11 | println(words) 12 | } 13 | /* Output: 14 | 11 15 | 1.4 16 | Twas Brillig 17 | */ 18 | -------------------------------------------------------------------------------- /Examples/VarAndVal/Vars.kt: -------------------------------------------------------------------------------- 1 | // VarAndVal/Vars.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main() { 5 | var whole = 11 // [1] 6 | var fractional = 1.4 // [2] 7 | var words = "Twas Brillig" // [3] 8 | println(whole) 9 | println(fractional) 10 | println(words) 11 | } 12 | /* Output: 13 | 11 14 | 1.4 15 | Twas Brillig 16 | */ 17 | -------------------------------------------------------------------------------- /Examples/Varargs/ListOf.kt: -------------------------------------------------------------------------------- 1 | // Varargs/ListOf.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | listOf(1) eq "[1]" 7 | listOf("a", "b") eq "[a, b]" 8 | } 9 | -------------------------------------------------------------------------------- /Examples/Varargs/MainArgConversion.kt: -------------------------------------------------------------------------------- 1 | // Varargs/MainArgConversion.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main(args: Array) { 5 | if (args.size < 3) return 6 | val first = args[0] 7 | val second = args[1].toInt() 8 | val third = args[2].toFloat() 9 | println("$first $second $third") 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Varargs/MainArgs.kt: -------------------------------------------------------------------------------- 1 | // Varargs/MainArgs.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | 4 | fun main(args: Array) { 5 | for (a in args) { 6 | println(a) 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Examples/Varargs/SpreadOperator.kt: -------------------------------------------------------------------------------- 1 | // Varargs/SpreadOperator.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import varargs.sum 4 | import atomictest.eq 5 | 6 | fun main() { 7 | val array = intArrayOf(4, 5) 8 | sum(1, 2, 3, *array, 6) eq 21 // [1] 9 | // Doesn't compile: 10 | // sum(1, 2, 3, array, 6) 11 | 12 | val list = listOf(9, 10, 11) 13 | sum(*list.toIntArray()) eq 30 // [2] 14 | } 15 | -------------------------------------------------------------------------------- /Examples/Varargs/Task1.kt: -------------------------------------------------------------------------------- 1 | // Varargs/Task1.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variableArgumentListsExercise1 4 | 5 | // fun foo(vararg i: Int, vararg s: String) {} 6 | 7 | fun main() { 8 | println("Multiple vararg-parameters are prohibited") 9 | } 10 | -------------------------------------------------------------------------------- /Examples/Varargs/Task2.kt: -------------------------------------------------------------------------------- 1 | // Varargs/Task2.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variableArgumentListsExercise2 4 | 5 | fun printArgs(s: String, vararg ints: Int) { 6 | println("$s${ints.toList()}") 7 | } 8 | 9 | fun main() { 10 | // printArgs("Numbers: ", 1, 2, 3) 11 | } 12 | /* Expected output: 13 | Numbers: [1, 2, 3] 14 | */ 15 | -------------------------------------------------------------------------------- /Examples/Varargs/Task5.kt: -------------------------------------------------------------------------------- 1 | // Varargs/Task5.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package variableArgumentListsExercise5 4 | 5 | fun main(args: Array) { 6 | println("Passed arguments:") 7 | for (arg in args) { 8 | println(arg) 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Examples/Varargs/VarargLikeList.kt: -------------------------------------------------------------------------------- 1 | // Varargs/VarargLikeList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varargs 4 | import atomictest.eq 5 | 6 | fun evaluate(vararg ints: Int) = 7 | "Size: ${ints.size}\n" + 8 | "Sum: ${ints.sum()}\n" + 9 | "Average: ${ints.average()}" 10 | 11 | fun main() { 12 | evaluate(10, -3, 8, 1, 9) eq """ 13 | Size: 5 14 | Sum: 25 15 | Average: 5.0 16 | """ 17 | } 18 | -------------------------------------------------------------------------------- /Examples/Varargs/VarargSum.kt: -------------------------------------------------------------------------------- 1 | // Varargs/VarargSum.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varargs 4 | import atomictest.eq 5 | 6 | fun sum(vararg numbers: Int): Int { 7 | var total = 0 8 | for (n in numbers) { 9 | total += n 10 | } 11 | return total 12 | } 13 | 14 | fun main() { 15 | sum(13, 27, 44) eq 84 16 | sum(1, 3, 5, 7, 9, 11) eq 36 17 | sum() eq 0 18 | } 19 | -------------------------------------------------------------------------------- /Examples/Varargs/VariableArgList.kt: -------------------------------------------------------------------------------- 1 | // Varargs/VariableArgList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package varargs 4 | 5 | fun v(s: String, vararg d: Double) {} 6 | 7 | fun main() { 8 | v("abc", 1.0, 2.0) 9 | v("def", 1.0, 2.0, 3.0, 4.0) 10 | v("ghi", 1.0, 2.0, 3.0, 4.0, 5.0, 6.0) 11 | } 12 | -------------------------------------------------------------------------------- /Examples/Visibility/Task4.kt: -------------------------------------------------------------------------------- 1 | // Visibility/Task4.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package constrainingVisibilityExercise4 4 | 5 | fun printSum(x: Int) { 6 | if (x <= 0) { 7 | println("Incorrect input: $x should be positive") 8 | return 9 | } 10 | println((0..x).sum()) 11 | } 12 | 13 | fun main() { 14 | printSum(-10) 15 | } 16 | /* Output: 17 | Incorrect input: -10 should be positive 18 | */ 19 | -------------------------------------------------------------------------------- /Examples/interoperability/AnnotateThrows.kt: -------------------------------------------------------------------------------- 1 | // interoperability/AnnotateThrows.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interop 4 | import java.io.IOException 5 | 6 | @Throws(IOException::class) 7 | fun hasCheckedException() { 8 | throw IOException() 9 | } 10 | -------------------------------------------------------------------------------- /Examples/interoperability/BigInt.kt: -------------------------------------------------------------------------------- 1 | // interoperability/BigInt.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package biginteger 4 | import java.math.BigInteger 5 | 6 | fun Int.toBigInteger(): BigInteger = 7 | BigInteger.valueOf(toLong()) 8 | 9 | fun String.toBigInteger(): BigInteger = 10 | BigInteger(this) 11 | 12 | operator fun BigInteger.plus( 13 | other: BigInteger 14 | ): BigInteger = add(other) 15 | -------------------------------------------------------------------------------- /Examples/interoperability/CallTopLevelFunction.java: -------------------------------------------------------------------------------- 1 | // interoperability/CallTopLevelFunction.java 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interoperability; 4 | import interop.TopLevelFunctionKt; 5 | import static atomictest.AtomicTestKt.eq; 6 | 7 | public class CallTopLevelFunction { 8 | public static void main(String[] args) { 9 | eq(TopLevelFunctionKt.hi(), "Hello!"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Examples/interoperability/CallTopLevelFunction2.java: -------------------------------------------------------------------------------- 1 | // interoperability/CallTopLevelFunction2.java 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interoperability; 4 | import static interop.TopLevelFunctionKt.hi; 5 | import static atomictest.AtomicTestKt.eq; 6 | 7 | public class CallTopLevelFunction2 { 8 | public static void main(String[] args) { 9 | eq(hi(), "Hello!"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Examples/interoperability/ChangeName.kt: -------------------------------------------------------------------------------- 1 | // interoperability/ChangeName.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | @file:JvmName("Utils") 4 | package interop 5 | 6 | fun salad() = "Lettuce!" 7 | -------------------------------------------------------------------------------- /Examples/interoperability/HiddenArrayList.kt: -------------------------------------------------------------------------------- 1 | // interoperability/HiddenArrayList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = mutableListOf(1, 2, 3) 7 | list.javaClass.name eq 8 | "java.util.ArrayList" 9 | } 10 | -------------------------------------------------------------------------------- /Examples/interoperability/JTool.java: -------------------------------------------------------------------------------- 1 | // interoperability/JTool.java 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interoperability; 4 | 5 | public class JTool { 6 | public static JTool get(String s) { 7 | if(s == null) return null; 8 | return new JTool(); 9 | } 10 | public String method() { 11 | return "Success"; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Examples/interoperability/JavaList.kt: -------------------------------------------------------------------------------- 1 | // interoperability/JavaList.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val list = listOf(1, 2, 3) 7 | (list is java.util.List<*>) eq true 8 | } 9 | -------------------------------------------------------------------------------- /Examples/interoperability/JavaWrapper.java: -------------------------------------------------------------------------------- 1 | // interoperability/JavaWrapper.java 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interoperability; 4 | import java.util.*; 5 | 6 | public class JavaWrapper { 7 | public static void main(String[] args) { 8 | // Primitive type 9 | int i = 10; 10 | // Wrapper types 11 | Integer iOrNull = null; 12 | List list = new ArrayList<>(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Examples/interoperability/KotlinChecked.kt: -------------------------------------------------------------------------------- 1 | // interoperability/KotlinChecked.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | import java.io.File 5 | 6 | fun main() { 7 | File("DataFiles/file_wubba.txt") 8 | .readLines()[0] eq 9 | "wubba lubba dub dub" 10 | } 11 | -------------------------------------------------------------------------------- /Examples/interoperability/KotlinClass.kt: -------------------------------------------------------------------------------- 1 | // interoperability/KotlinClass.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interop 4 | 5 | class Basic { 6 | var property1 = 1 7 | fun value() = property1 * 10 8 | } 9 | -------------------------------------------------------------------------------- /Examples/interoperability/KotlinDataClass.kt: -------------------------------------------------------------------------------- 1 | // interoperability/KotlinDataClass.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interoperability 4 | 5 | data class Staff( 6 | var name: String, 7 | var role: String 8 | ) 9 | -------------------------------------------------------------------------------- /Examples/interoperability/KotlinWrapper.kt: -------------------------------------------------------------------------------- 1 | // interoperability/KotlinWrapper.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interop 4 | 5 | fun main() { 6 | // Generates a primitive int: 7 | val i = 10 8 | // Generates wrapper types: 9 | val iOrNull: Int? = null 10 | val list: List = listOf(1, 2, 3) 11 | } 12 | -------------------------------------------------------------------------------- /Examples/interoperability/MakeSalad.java: -------------------------------------------------------------------------------- 1 | // interoperability/MakeSalad.java 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interoperability; 4 | import interop.Utils; 5 | import static atomictest.AtomicTestKt.eq; 6 | 7 | public class MakeSalad { 8 | public static void main(String[] args) { 9 | eq(Utils.salad(), "Lettuce!"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Examples/interoperability/Random.kt: -------------------------------------------------------------------------------- 1 | // interoperability/Random.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | import java.util.Random 5 | 6 | fun main() { 7 | val rand = Random(47) 8 | rand.nextInt(100) eq 58 9 | } 10 | -------------------------------------------------------------------------------- /Examples/interoperability/ReadOnlyByDefault.kt: -------------------------------------------------------------------------------- 1 | // interoperability/ReadOnlyByDefault.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interop 4 | 5 | data class Animal(val name: String) 6 | 7 | interface Zoo { 8 | fun viewAnimals(): Collection 9 | } 10 | 11 | fun visitZoo(zoo: Zoo) { 12 | val animals = zoo.viewAnimals() 13 | // Compile-time error: 14 | // animals.add(Animal("Grumpy Cat")) 15 | } 16 | -------------------------------------------------------------------------------- /Examples/interoperability/ReadOnlyCollections.kt: -------------------------------------------------------------------------------- 1 | // interoperability/ReadOnlyCollections.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import atomictest.eq 4 | 5 | fun main() { 6 | val mutable = mutableListOf(1, 2, 3) 7 | // Read-only reference to a mutable list: 8 | val list: List = mutable 9 | mutable += 4 10 | // list has changed: 11 | list eq "[1, 2, 3, 4]" 12 | } 13 | -------------------------------------------------------------------------------- /Examples/interoperability/TopLevelFunction.kt: -------------------------------------------------------------------------------- 1 | // interoperability/TopLevelFunction.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interop 4 | 5 | fun hi() = "Hello!" 6 | -------------------------------------------------------------------------------- /Examples/interoperability/UseBeanClass.kt: -------------------------------------------------------------------------------- 1 | // interoperability/UseBeanClass.kt 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | import interoperability.Chameleon 4 | import atomictest.eq 5 | 6 | fun main() { 7 | val chameleon = Chameleon() 8 | chameleon.size = 1 9 | chameleon.size eq 1 10 | chameleon.color = "green" 11 | chameleon.color eq "green" 12 | chameleon.color = "turquoise" 13 | chameleon.color eq "turquoise" 14 | } 15 | -------------------------------------------------------------------------------- /Examples/interoperability/UsingKotlinClass.java: -------------------------------------------------------------------------------- 1 | // interoperability/UsingKotlinClass.java 2 | // (c)2021 Mindview LLC. See Copyright.txt for permissions. 3 | package interoperability; 4 | import interop.Basic; 5 | import static atomictest.AtomicTestKt.eq; 6 | 7 | public class UsingKotlinClass { 8 | public static void main(String[] args) { 9 | Basic b = new Basic(); 10 | eq(b.getProperty1(), 1); 11 | b.setProperty1(12); 12 | eq(b.value(), 120); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Tests/unittesting/SampleTest.kt: -------------------------------------------------------------------------------- 1 | // Tests/unittesting/SampleTest.kt 2 | package unittesting 3 | import kotlin.test.* 4 | 5 | class SampleTest { 6 | @Test 7 | fun testFortyTwo() { 8 | expect(42, "Incorrect,") { fortyTwo() } 9 | } 10 | @Test 11 | fun testAllGood() { 12 | assertTrue(allGood(), "Not good") 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /buildSrc/build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | `kotlin-dsl` 3 | } 4 | 5 | repositories { 6 | mavenCentral() 7 | } -------------------------------------------------------------------------------- /etc/ExcludedExamples/FromKotlin/BeanClass.java: -------------------------------------------------------------------------------- 1 | // FromKotlin/BeanClass.java 2 | package fromkotlin; 3 | 4 | public class BeanClass { 5 | private int size = 100; 6 | private String desc = "Bean"; 7 | public int getSize() { return size; } 8 | public void setSize(int newSize) { 9 | size = newSize; 10 | } 11 | public String getDescription() { 12 | return desc; 13 | } 14 | public void setDescription(String newDesc) { 15 | desc = newDesc; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /etc/ExcludedExamples/FromKotlin/DisplayList.kt: -------------------------------------------------------------------------------- 1 | // FromKotlin/DisplayList.kt 2 | import java.util.* 3 | 4 | fun List<*>.display() { 5 | println("[") 6 | for(e in this) 7 | println(" $e") 8 | println("]") 9 | } 10 | 11 | fun main(args: Array) { 12 | val list = Arrays.asList("AA", "BB", "CC") 13 | list.display() 14 | } 15 | -------------------------------------------------------------------------------- /etc/ExcludedExamples/FromKotlin/Random.kt: -------------------------------------------------------------------------------- 1 | // FromKotlin/Random.kt 2 | import atomictest.eq 3 | import java.util.Random 4 | 5 | fun main(args: Array) { 6 | val rand = Random(47) 7 | rand.nextInt(100) eq 58 8 | } 9 | -------------------------------------------------------------------------------- /etc/ExcludedExamples/FromKotlin/UseBeanClass.kt: -------------------------------------------------------------------------------- 1 | // FromKotlin/UseBeanClass.kt 2 | import atomictest.eq 3 | import fromkotlin.BeanClass 4 | 5 | fun main(args: Array) { 6 | val bean = BeanClass() 7 | bean.size eq 100 8 | bean.description eq "Bean" 9 | bean.size = 10 10 | bean.size eq 10 11 | bean.description = "Smaller" 12 | bean.description eq "Smaller" 13 | } 14 | -------------------------------------------------------------------------------- /etc/Experiments/Capture.kt: -------------------------------------------------------------------------------- 1 | fun except(f: () -> String) = 2 | try { 3 | f() 4 | } catch(e: Exception) { 5 | e.message 6 | } 7 | 8 | fun main(args: Array) { 9 | println(except { throw Exception("bar") }) 10 | } 11 | -------------------------------------------------------------------------------- /etc/Experiments/CombineToString.kt: -------------------------------------------------------------------------------- 1 | fun combineToString(num1: T, num2: T) = "$num1$num2" 2 | 3 | fun main(args: Array) { 4 | val nums = arrayOf(7, 42.7) 5 | println("Combined Numbers: ${combineToString(nums[0], nums[1])}") 6 | } 7 | 8 | -------------------------------------------------------------------------------- /etc/Experiments/Coroutines1.kt: -------------------------------------------------------------------------------- 1 | import kotlinx.coroutines.experimental.* 2 | 3 | fun main(args: Array) { 4 | println("Start") 5 | 6 | // Start a coroutine 7 | launch { 8 | delay(1000) 9 | println("Hello") 10 | } 11 | 12 | Thread.sleep(2000) // wait for 2 seconds 13 | println("Stop") 14 | } 15 | -------------------------------------------------------------------------------- /etc/Experiments/Coroutines2.kt: -------------------------------------------------------------------------------- 1 | import kotlinx.coroutines.experimental.* 2 | 3 | fun main(args: Array) = runBlocking { 4 | val jobs = List(100_000) { 5 | launch { 6 | delay(1000L) 7 | print(".") 8 | } 9 | } 10 | jobs.forEach { it.join() } 11 | } 12 | -------------------------------------------------------------------------------- /etc/Experiments/Covariant.kt: -------------------------------------------------------------------------------- 1 | open class Animal 2 | class Cat: Animal() 3 | 4 | fun main(args: Array) { 5 | val cats: List = listOf(Cat(), Cat()) 6 | val animals: List = cats 7 | } 8 | -------------------------------------------------------------------------------- /etc/Experiments/DogAndRobot.kt: -------------------------------------------------------------------------------- 1 | interface Speaks { 2 | val speak: String 3 | } 4 | 5 | data class Dog(override val speak: String = "bark!"): Speaks 6 | data class Robot(override val speak: String = "clank!"): Speaks 7 | 8 | //inline fun talk(t: T) = t.speak 9 | fun talk(t: Speaks) = t.speak 10 | 11 | fun main(args: Array) { 12 | println(talk(Dog())) 13 | println(talk(Robot())) 14 | } -------------------------------------------------------------------------------- /etc/Experiments/DogAndRobot2.kt: -------------------------------------------------------------------------------- 1 | package experiments 2 | 3 | data class Dog(val speak: String = "bark!") 4 | data class Robot(val speak: String = "clank!") 5 | 6 | //fun talk(t: T) = when { 7 | fun talk(t: Any) = when { 8 | t is Dog -> t.speak 9 | t is Robot -> t.speak 10 | else -> "" 11 | } 12 | 13 | fun main(args: Array) { 14 | println(talk(Dog())) 15 | println(talk(Robot())) 16 | } -------------------------------------------------------------------------------- /etc/Experiments/Invariant.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | class Animal {} 4 | class Cat extends Animal {} 5 | 6 | public class Invariant { 7 | public static void main(String[] args) { 8 | List animals = new ArrayList(); 9 | // error: incompatible types: ArrayList 10 | // cannot be converted to List 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /etc/Experiments/JHelper.java: -------------------------------------------------------------------------------- 1 | //package jhelper; 2 | public class JHelper { 3 | public static JHelper jF() { return null; } 4 | public void M() {} 5 | } -------------------------------------------------------------------------------- /etc/Experiments/LambdaVariations.kt: -------------------------------------------------------------------------------- 1 | // lambdas/LambdaVariations.kt 2 | 3 | class Lambdas { 4 | val bare = {} 5 | val oneArg = { i: Int -> i * 2 } 6 | //val oneArg2 = { i -> i * 2 } 7 | val oneArg3 = { it * 2 } 8 | val twoArgs = { i: Int, n: Int -> i * n } 9 | } 10 | -------------------------------------------------------------------------------- /etc/Experiments/Reified.kt: -------------------------------------------------------------------------------- 1 | inline fun membersOf() = T::class.members 2 | 3 | fun main(s: Array) { 4 | println(membersOf().joinToString("\n")) 5 | } 6 | -------------------------------------------------------------------------------- /etc/Experiments/Reified2.kt: -------------------------------------------------------------------------------- 1 | fun type(c: Any) = c::class.qualifiedName 2 | 3 | fun main(s: Array) { 4 | println(type("")) 5 | } 6 | -------------------------------------------------------------------------------- /etc/Experiments/ToString.kt: -------------------------------------------------------------------------------- 1 | fun toStr(t: T, u: U, v: V) = "$t$u$v" 2 | fun toStr2(t: Any, u: Any, v: Any) = "$t$u$v" 3 | 4 | fun main(args: Array) { 5 | println(toStr("bob", 37, 1.005)) 6 | println(toStr2("bob", 37, 1.005)) 7 | } 8 | -------------------------------------------------------------------------------- /etc/Experiments/TypeInfoNull.kt: -------------------------------------------------------------------------------- 1 | fun main(args: Array) { 2 | val s = "Hello" 3 | println(s::class) 4 | println(s::class.java) 5 | println(s::class.typeParameters) 6 | //val n = null 7 | //val n2 = n 8 | //println(n2!!::class) 9 | } 10 | -------------------------------------------------------------------------------- /etc/Experiments/UnpackInLambda.kt: -------------------------------------------------------------------------------- 1 | // lambdas/UnpackInLambda.kt 2 | import atomicTest.eq 3 | 4 | fun main(args: Array) { 5 | val items = "abc".withIndex().map { (n, ch) -> "$n: $ch" } 6 | items eq "[0: a, 1: b, 2: c]" 7 | } 8 | -------------------------------------------------------------------------------- /etc/Experiments/UseJHelper.kt: -------------------------------------------------------------------------------- 1 | import jhelper.* 2 | fun main(args: Array) { 3 | val a = JHelper.jF() 4 | a.M() //Oops! 5 | } -------------------------------------------------------------------------------- /etc/Experiments/buildjar.bat: -------------------------------------------------------------------------------- 1 | rem @echo Main-Class: oodesign.ExploreMazeKt> manifest.txt 2 | kotlinc -include-runtime ExploreMaze.kt Factory.kt MazeView.kt Players.kt Result.kt RobotMaze.kt Room.kt Stage.kt Urge.kt View.kt ..\AtomicTest\AtomicTest.kt -d ExploreMaze.jar 3 | rem jar ufm ExploreMaze.jar manifest.txt 4 | -------------------------------------------------------------------------------- /etc/GenerateReadmeTOC.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | python GenerateReadmeTOC.py 3 | -------------------------------------------------------------------------------- /etc/ObjectOrientedDesign/settings.gradle.kts: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/etc/ObjectOrientedDesign/settings.gradle.kts -------------------------------------------------------------------------------- /etc/makefile: -------------------------------------------------------------------------------- 1 | JC = "/Program Files/Java/jdk1.8.0_102/bin/javac.exe" 2 | 3 | %Kt.class: %.kt 4 | kotlinc $< 5 | 6 | %.class: %.java 7 | echo %PATH% 8 | $JC $< 9 | 10 | all: BeanClass.class RandomKt.class UseBeanClassKt.class 11 | 12 | -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | org.gradle.parallel=true 2 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-bin.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /images/buildgradle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/images/buildgradle.png -------------------------------------------------------------------------------- /images/helloworld.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/images/helloworld.png -------------------------------------------------------------------------------- /images/main.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/images/main.png -------------------------------------------------------------------------------- /images/runhelloworld.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/images/runhelloworld.png -------------------------------------------------------------------------------- /images/runmain.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BruceEckel/AtomicKotlinExamples/18d4e8913ad80df41ea474af9b8987266771c8f4/images/runmain.png -------------------------------------------------------------------------------- /settings.config: -------------------------------------------------------------------------------- 1 | base_name = "AtomicKotlin" 2 | language_name = "kotlin" 3 | code_ext = "kt" 4 | start_comment = "//" 5 | extracted_examples = Path(os.environ['GIT_HOME']) / "AtomicKotlinExamples" 6 | exclude_atoms = """ 7 | """.strip().split() 8 | # Previously contained FromKotlin 9 | -------------------------------------------------------------------------------- /settings.gradle.kts: -------------------------------------------------------------------------------- 1 | rootProject.name = "Examples" 2 | -------------------------------------------------------------------------------- /test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | echo gradlew clean 3 | ./gradlew clean 4 | echo bb code extract 5 | bb code extract without_duplicates 6 | echo rm Tests/TestExamples.java 7 | rm Tests/TestExamples.java 8 | echo gradlew GenerateTests 9 | ./gradlew GenerateTests 10 | echo gradlew test 11 | ./gradlew test 12 | --------------------------------------------------------------------------------