cdiggins

class ConceptExamples 
{
  Number Lerp(Number a, Number b, double t)
    => a * t + b * (1.0 - t);
    
  Number Dot(Vector v) 
    => (v * v).Sum().Sqrt();
    
  Number Sum(Array xs)
    => xs.Aggregate((x, y) => x + y);

cdiggins

namespace Plato;

#region Groups

// https://en.wikipedia.org/wiki/Algebraic_group
interface IGroup<T>
    where T : IGroup<T>
{
    T GroupOperation(T x);
}

cdiggins

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

[ExecuteAlways]
public class PMoveTowards : MonoBehaviour
{

cdiggins

public interface IAnimationCurve
{
    double this[double t] { get; }
    double Duration { get; }
}

public class AnimationClip<T> : IAnimationClip<T>
{
    public AnimationClip(IAnimationCurve curve, T from, T to, Func<T, T, double, T> lerp)

cdiggins

public interface IAnimator
{
    IArray<IAnimation> Animations { get; }
    IAnimator Start(IAnimation anim);
    IAnimator End(IAnimation anim);
    IAnimator IsRunning();

    T Drive<T>(IAnimation animation, Func<T, T, float, T> lerp);
}

cdiggins

    // Here is the basic class 
    public class Vector2_ClassNaive
    {
        public double x, y;
    }

    // Once we decide immutability is a good thing 
    public class Vector2_ClassWithFields
    {
        public readonly double x, y;

cdiggins

using System;
using Plato;

public class VectorAttribute : Attribute { }
public class ValueAttribute : Attribute { }
public class MeasureAttribute : Attribute { }
public class NumberAttribute : Attribute { }
public class IntervalAttribute : Attribute { }

namespace Plato 

cdiggins

using System;

namespace Plato
{
    public partial struct Float2 : IVector<float>
    {
        public float X { get; }
        public float Y { get; }
    }

cdiggins

    public class Unit { }
    public class Kilograms : Unit { }
    public class Seconds : Unit { }
    public class Meters : Unit { }
    public class Radians : Unit { }
    public class MultiplyUnits<TUnit1, TUnit2> : Unit where TUnit1 : Unit where TUnit2 : Unit { }
    public class DivideUnits<TUnit1, TUnit2> : Unit where TUnit1 : Unit where TUnit2 : Unit { }
    
    public class Measure<T> where T : Unit
    {

cdiggins

    public partial struct Angle : INumber
    {
        public double Radians { get; }
        public const double RadiansPerRevolution = Math.PI * 2;
        public const double DegreesPerRevolution = 360;
        public const string InternalUnit = nameof(Radians);
        public static Angle FromRadians(double radians) => new Angle(radians);
        public static Angle FromRevolutions(double revolutions) => revolutions * RadiansPerRevolution;
        public static Angle FromDegrees(double degrees) => FromRevolutions(DegreesPerRevolution / degrees);
        public double ToDegrees() => DegreesPerRevolution * ToRevolutions();