trackler 2.0.6.19 → 2.0.6.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8623ef341a6390932eb5e0f88373f12e87dddd8e
-  data.tar.gz: 14daf2f37b0190a64c8edf17ffa28cf39a25d961
+  metadata.gz: a74906359ef6716f5ba79719f22de614e19f79a7
+  data.tar.gz: ae56be98e926ec4f4cf082af5c727a0f842b8eb0
 SHA512:
-  metadata.gz: a01f8a0581847e5513dcd1f48ab9766b70753042174c717b97269da1af841184dbeb4ced3be2053ec2dae9376741a6e2c176bee7848160028f535b591941b8c2
-  data.tar.gz: be768c3c71174ab29c6922f2f31c5fdf754616b0d58b69ae94b0ea7c6a92837c130184d41d72c5c5f842491f4d17b99eeaef4a42c2e633f57a2235143117b9c5
+  metadata.gz: 7b4bb7fc87665af298f845160c685eef1d49480443b61f4f98be954bcfda314cc145230bf62c0f7b16ab3cbcc5873ca0698f116a3c30379ef101ca3cec44a232
+  data.tar.gz: 3be91f09a9535cab6a09afa6911fdd262bcac4dc28b36cf1ff400a71b2a83f28888a08134c1a6653d5459b6311c18b10eb5be070621664fa131898339410d5d6

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.19"
+  VERSION = "2.0.6.20"
 end

data/tracks/csharp/config.json

@@ -831,6 +831,14 @@
         "Dictionaries"
       ]
     },
+    {
+      "slug": "forth",
+      "difficulty": 10,
+      "topics": [
+        "Parsing",
+        "Stacks"
+      ]
+    },
     {
       "slug": "pov",
       "difficulty": 10,

data/tracks/csharp/exercises/forth/Example.cs

@@ -0,0 +1,257 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Sprache;
+
+public enum ForthError
+{
+    DivisionByZero,
+    StackUnderflow,
+    InvalidWord,
+    UnknownWord
+}
+
+public class ForthException : Exception
+{
+    public ForthException(ForthError error)
+    {
+        Error = error;
+    }
+
+    public ForthError Error { get; }
+}
+
+public class ForthState
+{
+    public Stack<int> Stack { get; } = new Stack<int>();
+    public Dictionary<string, IEnumerable<ForthDefinition>> Mapping { get; } = new Dictionary<string, IEnumerable<ForthDefinition>>();
+
+    public override string ToString() => string.Join(" ", Stack.Reverse());
+}
+
+public abstract class ForthDefinition
+{
+    public abstract void Evaluate(ForthState state);    
+}
+
+public abstract class TermDefinition : ForthDefinition
+{
+    public TermDefinition(string term)
+    {
+        Term = term;
+    }
+
+    public string Term { get; }
+
+    public override void Evaluate(ForthState state)
+    {
+        if (IsUserTerm(state))
+            EvaluateUserTerm(state);
+        else
+            EvaluateDefaultTerm(state);
+    }
+
+    private bool IsUserTerm(ForthState state) => state.Mapping.ContainsKey(Term);
+
+    public virtual void EvaluateUserTerm(ForthState state)
+    {
+        foreach (var definition in state.Mapping[Term])
+            definition.Evaluate(state);
+    }
+
+    public abstract void EvaluateDefaultTerm(ForthState state);
+}
+
+public abstract class UnaryOperation: TermDefinition
+{
+    public UnaryOperation(string term) : base(term)
+    {
+    }
+
+    public override void EvaluateDefaultTerm(ForthState state)
+    {        
+        if (state.Stack.Count < 1)
+            throw new ForthException(ForthError.StackUnderflow);
+
+        var operand = state.Stack.Pop();
+
+        foreach (var value in operation(operand))
+            state.Stack.Push(value);
+    }
+
+    public abstract List<int> operation(int x);
+}
+
+public abstract class BinaryOperation : TermDefinition
+{
+    public BinaryOperation(string term) : base(term)
+    {
+    }
+
+    public override void EvaluateDefaultTerm(ForthState state)
+    {
+        if (state.Stack.Count <= 1)
+            throw new ForthException(ForthError.StackUnderflow);
+
+        var operand2 = state.Stack.Pop();
+        var operand1 = state.Stack.Pop();
+
+        foreach (var value in operation(operand1, operand2))
+            state.Stack.Push(value);
+    }
+
+    public abstract List<int> operation(int x, int y);
+}
+
+public class Constant : ForthDefinition
+{
+    private readonly int n;
+
+    public Constant(int n)
+    {
+        this.n = n;
+    }
+
+    public override void Evaluate(ForthState state) => state.Stack.Push(n);
+}
+
+public class Word : TermDefinition
+{
+    public Word(string str) : base(str)
+    {
+    }
+
+    public override void EvaluateDefaultTerm(ForthState state)
+    {
+        if (!state.Mapping.ContainsKey(Term))
+            throw new ForthException(ForthError.UnknownWord);
+    }
+}
+
+public class Dup: UnaryOperation
+{
+    public Dup() : base("dup") {}
+    public override List<int> operation(int x) => new List<int> { x, x };
+}
+
+public class Drop : UnaryOperation
+{
+    public Drop() : base("drop") {}
+    public override List<int> operation(int x) => new List<int>();
+}
+
+public class Swap : BinaryOperation
+{
+    public Swap() : base("swap") {}
+    public override List<int> operation(int x, int y) => new List<int> { y, x };
+}
+
+public class Over : BinaryOperation
+{
+    public Over() : base("over") {}
+    public override List<int> operation(int x, int y) => new List<int> { x, y, x };
+}
+
+public class Plus : BinaryOperation
+{
+    public Plus() : base("+") {}
+    public override List<int> operation(int x, int y) => new List<int> { x + y };
+}
+
+public class Minus : BinaryOperation
+{
+    public Minus() : base("-") {}
+    public override List<int> operation(int x, int y) => new List<int> { x - y };
+}
+
+public class Multiply : BinaryOperation
+{
+    public Multiply() : base("*") {}
+    public override List<int> operation(int x, int y) => new List<int> { x * y };
+}
+
+public class Division : BinaryOperation
+{
+    public Division() : base("/") {}
+
+    public override List<int> operation(int x, int y)
+    {
+        if (y == 0)
+            throw new ForthException(ForthError.DivisionByZero);
+
+        return new List<int> { x / y };
+    }
+}
+
+public class CustomTerm : ForthDefinition
+{
+    private readonly string term;
+    private readonly IEnumerable<ForthDefinition> actions;
+
+    public CustomTerm(string term, IEnumerable<ForthDefinition> actions)
+    {
+        this.term = term;
+        this.actions = actions;
+    }
+
+    public override void Evaluate(ForthState state)
+    {
+        int result;
+        if (int.TryParse(term, out result))
+            throw new ForthException(ForthError.InvalidWord);
+
+        state.Mapping[term] = actions;
+    }
+}
+
+public static class Forth
+{
+    public static string Eval(string input)
+    {
+        var expression = Expression.Parse(input);
+        var state = new ForthState();
+
+        foreach (var definition in expression)
+            definition.Evaluate(state);
+
+        return state.ToString();
+    }
+    
+    private static readonly Parser<Constant> Constant =
+        from number in Parse.Number
+        from whitespace in Parse.WhiteSpace.Optional()
+        select new Constant(int.Parse(number));
+
+    private static readonly Parser<string> TermIdentifier =
+        from term in Parse.Regex(@"[^\s;]+")
+        from whitespace in Parse.WhiteSpace.Optional()
+        select term.ToLowerInvariant();
+
+    private static readonly Parser<ForthDefinition> Term = TermIdentifier.Select<string, ForthDefinition>(term =>
+    {
+        switch (term)
+        {
+            case "+": return new Plus();
+            case "-": return new Minus();
+            case "*": return new Multiply();
+            case "/": return new Division();
+            case "dup": return new Dup();
+            case "drop": return new Drop();
+            case "swap": return new Swap();
+            case "over": return new Over();
+            default: return new Word(term);
+        }
+    });
+
+    private static readonly Parser<ForthDefinition> CustomTerm =
+        from a in Parse.Char(':')
+        from b in Parse.WhiteSpace
+        from customTerm in TermIdentifier
+        from definitions in Constant.XOr(Term).AtLeastOnce()            
+        from d in Parse.Char(';')
+        from e in Parse.WhiteSpace.Optional()
+        select new CustomTerm(customTerm, definitions);
+
+    private static readonly Parser<IEnumerable<ForthDefinition>> Expression =
+        (CustomTerm.XOr(Constant).XOr(Term)).Many();
+}

data/tracks/csharp/exercises/forth/ForthTest.cs

@@ -0,0 +1,134 @@
+using NUnit.Framework;
+
+public class ForthTest
+{
+    [Test]
+    public void No_input()
+    {
+        Assert.That(Forth.Eval(""), Is.EqualTo(""));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Numbers_just_get_pushed_onto_the_stack()
+    {
+        Assert.That(Forth.Eval("1 2 3 4 5"), Is.EqualTo("1 2 3 4 5"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Non_word_characters_are_separators()
+    {
+        Assert.That(Forth.Eval("1\v2\t3\n4\r5 6\t7"), Is.EqualTo("1 2 3 4 5 6 7"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basic_arithmetic()
+    {
+        Assert.That(Forth.Eval("1 2 + 4 -"), Is.EqualTo("-1"));
+        Assert.That(Forth.Eval("2 4 * 3 /"), Is.EqualTo("2"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Division_by_zero()
+    {
+        var exception = Assert.Throws<ForthException>(() => Forth.Eval("4 2 2 - /"));
+        Assert.That(exception.Error, Is.EqualTo(ForthError.DivisionByZero));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void dup()
+    {
+        Assert.That(Forth.Eval("1 DUP"), Is.EqualTo("1 1"));
+        Assert.That(Forth.Eval("1 2 Dup"), Is.EqualTo("1 2 2"));
+
+        var exception = Assert.Throws<ForthException>(() => Forth.Eval("dup"));
+        Assert.That(exception.Error, Is.EqualTo(ForthError.StackUnderflow));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void drop()
+    {
+        Assert.That(Forth.Eval("1 drop"), Is.EqualTo(""));
+        Assert.That(Forth.Eval("1 2 drop"), Is.EqualTo("1"));
+
+        var exception = Assert.Throws<ForthException>(() => Forth.Eval("drop"));
+        Assert.That(exception.Error, Is.EqualTo(ForthError.StackUnderflow));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void swap()
+    {
+        Assert.That(Forth.Eval("1 2 swap"), Is.EqualTo("2 1"));
+        Assert.That(Forth.Eval("1 2 3 swap"), Is.EqualTo("1 3 2"));
+
+        var exception1 = Assert.Throws<ForthException>(() => Forth.Eval("1 swap"));
+        Assert.That(exception1.Error, Is.EqualTo(ForthError.StackUnderflow));
+
+        var exception2 = Assert.Throws<ForthException>(() => Forth.Eval("swap"));
+        Assert.That(exception2.Error, Is.EqualTo(ForthError.StackUnderflow));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void over()
+    {
+        Assert.That(Forth.Eval("1 2 over"), Is.EqualTo("1 2 1"));
+        Assert.That(Forth.Eval("1 2 3 over"), Is.EqualTo("1 2 3 2"));
+
+        var exception1 = Assert.Throws<ForthException>(() => Forth.Eval("1 over"));
+        Assert.That(exception1.Error, Is.EqualTo(ForthError.StackUnderflow));
+
+        var exception2 = Assert.Throws<ForthException>(() => Forth.Eval("over"));
+        Assert.That(exception2.Error, Is.EqualTo(ForthError.StackUnderflow));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Defining_a_new_word()
+    {
+        Assert.That(Forth.Eval(": dup-twice dup dup ; 1 dup-twice"), Is.EqualTo("1 1 1"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Redefining_an_existing_word()
+    {
+        Assert.That(Forth.Eval(": foo dup ; : foo dup dup ; 1 foo"), Is.EqualTo("1 1 1"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Redefining_an_existing_built_in_word()
+    {
+        Assert.That(Forth.Eval(": swap dup ; 1 swap"), Is.EqualTo("1 1"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Defining_words_with_odd_characters()
+    {
+        Assert.That(Forth.Eval(": € 220371 ; €"), Is.EqualTo("220371"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Defining_a_number()
+    {
+        var exception = Assert.Throws<ForthException>(() => Forth.Eval(": 1 2 ;"));
+        Assert.That(exception.Error, Is.EqualTo(ForthError.InvalidWord));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Calling_a_non_existing_word()
+    {
+        var exception = Assert.Throws<ForthException>(() => Forth.Eval("1 foo"));
+        Assert.That(exception.Error, Is.EqualTo(ForthError.UnknownWord));
+    }
+}

data/tracks/fsharp/config.json

@@ -795,6 +795,13 @@
         "Optional values"
       ]
     },
+    {
+      "slug": "lens-person",
+      "difficulty": 9,
+      "topics": [
+        "Lenses"
+      ]
+    },
     {
       "slug": "sgf-parsing",
       "difficulty": 9,
@@ -850,7 +857,6 @@
   ],
   "foregone": [
     "flatten-array",
-    "lens-person",
     "nucleotide-codons",
     "paasio",
     "point-mutations",