Jellyfin.Plugin.SmartPlaylist/Lisp/Compiler/Parser.cs

@@ -1,7 +1,269 @@
 using System.Diagnostics;
-using Jellyfin.Plugin.SmartPlaylist.Lisp;
 
 namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
+    interface IAddable<T> where T : IAddable<T> {
+        static abstract T operator +(T left, T right);
+    }
+
+    interface ISubtractable<T> where T : ISubtractable<T> {
+        static abstract T operator -(T left, T right);
+    }
+
+    interface IMultiplicatable<T> where T : IMultiplicatable<T> {
+        static abstract T operator *(T left, T right);
+    }
+
+    interface IDivisible<T> where T : IDivisible<T> {
+        static abstract T operator /(T left, T right);
+        static abstract T operator %(T left, T right);
+    }
+
+    interface ISortable<T, E> where T : ISortable<T, E> {
+        static abstract E operator >(T left, T right);
+        static abstract E operator <(T left, T right);
+        static abstract E operator >=(T left, T right);
+        static abstract E operator <=(T left, T right);
+    }
+
+    interface IComparable<T, E> where T : IComparable<T, E> {
+        static abstract E operator ==(T left, T right);
+        static abstract E operator !=(T left, T right);
+        E Equals(T other);
+    }
+
+    public abstract class Expression: IComparable<Expression, bool> {
+        public override abstract string ToString();
+        public abstract override int GetHashCode();
+        public abstract bool Equals(Expression other);
+        public override bool Equals(object? other) {
+            if (other is Expression other_e) {
+                return Equals(other_e);
+            }
+            return false;
+        }
+        public static bool operator ==(Expression left, Expression right) {
+            return left.Equals(right);
+        }
+        public static bool operator !=(Expression left, Expression right) {
+            return !left.Equals(right);
+        }
+        public abstract object Inner();
+    }
+    public abstract class Atom : Expression {}
+    public class Symbol : Atom {
+        private readonly string _name;
+        public Symbol(string name) {
+            _name = name;
+        }
+        public string name { get => _name; }
+        public override int GetHashCode() {
+            int hash = 17;
+            hash *= 23;
+            hash += _name.GetHashCode();
+            return hash;
+        }
+        public override bool Equals(Expression? other) {
+            if (other is Symbol other_s) {
+                return _name == other_s._name;
+            }
+            return false;
+        }
+        public override string ToString() {
+            return _name;
+        }
+        public override object Inner() {
+            return _name;
+        }
+    }
+
+    public class Boolean : Atom {
+        private readonly bool _value;
+        public Boolean(bool value) {
+            _value = value;
+        }
+        public bool value { get => _value; }
+        public override int GetHashCode() {
+            int hash = 17;
+            hash *= 23;
+            hash += _value.GetHashCode();
+            return hash;
+        }
+        public override bool Equals(Expression other) {
+            if (other is Boolean other_b) {
+                return _value == other_b.value;
+            }
+            return false;
+        }
+        public override string ToString() {
+            return _value? "t" : "nil";
+        }
+        public override object Inner() {
+            return _value;
+        }
+    }
+
+    public class Integer : Atom, IAddable<Integer>, ISubtractable<Integer>, IMultiplicatable<Integer>, IDivisible<Integer>, ISortable<Integer, Boolean> {
+        private readonly int _value;
+        public Integer(int value) {
+            _value = value;
+        }
+        public int value { get => _value; }
+        public override int GetHashCode() {
+            int hash = 17;
+            hash *= 23;
+            hash += _value.GetHashCode();
+            return hash;
+        }
+        public override bool Equals(Expression other) {
+            if (other is Integer other_i) {
+                return _value == other_i._value;
+            }
+            return false;
+        }
+        public override string ToString() {
+            return _value.ToString();
+        }
+        public static Integer operator +(Integer a, Integer b) {
+            return new Integer(a.value + b.value);
+        }
+        public static Integer operator -(Integer a, Integer b) {
+            return new Integer(a.value - b.value);
+        }
+        public static Integer operator *(Integer a, Integer b) {
+            return new Integer(a.value * b.value);
+        }
+        public static Integer operator /(Integer a, Integer b) {
+            return new Integer(a.value / b.value);
+        }
+        public static Integer operator %(Integer a, Integer b) {
+            return new Integer(a.value % b.value);
+        }
+        public static Boolean operator >(Integer a, Integer b) {
+            return new Boolean(a.value > b.value);
+        }
+        public static Boolean operator <(Integer a, Integer b) {
+            return new Boolean(a.value < b.value);
+        }
+        public static Boolean operator >=(Integer a, Integer b) {
+            return new Boolean(a.value >= b.value);
+        }
+        public static Boolean operator <=(Integer a, Integer b) {
+            return new Boolean(a.value <= b.value);
+        }
+        public static Boolean operator ==(Integer a, Integer b) {
+            return new Boolean(a.value == b.value);
+        }
+        public static Boolean operator !=(Integer a, Integer b) {
+            return new Boolean(a.value != b.value);
+        }
+        public override object Inner() {
+            return _value;
+        }
+    }
+
+    public class String : Atom, IAddable<String> {
+        private readonly string _value;
+        public String(string value) {
+            _value = value;
+        }
+        public string value { get => _value; }
+        public override int GetHashCode() {
+            int hash = 17;
+            hash *= 23;
+            hash += _value.GetHashCode();
+            return hash;
+        }
+        public override bool Equals(Expression other) {
+            if (other is String other_s) {
+                return _value == other_s._value;
+            }
+            return false;
+        }
+        public override string ToString() {
+            return "\"" + _value + "\"";
+        }
+        public static String operator +(String a, String b) {
+            return new String (a.value + b.value);
+        }
+        public override object Inner() {
+            return _value;
+        }
+    }
+
+    public class Object : Atom {
+        private readonly object _value;
+        public Object(object value) {
+            _value = value;
+        }
+        public object value { get => _value; }
+        public override int GetHashCode() {
+            int hash = 17;
+            hash *= 23;
+            hash += _value.GetHashCode();
+            return hash;
+        }
+        public override bool Equals(Expression other) {
+            if (other is Object other_o) {
+                return _value == other_o._value;
+            }
+            return false;
+        }
+        public override string ToString() {
+            return _value.ToString();
+        }
+        public static Expression FromBase(object o) {
+            switch (o) {
+                case bool b:
+                    return new Boolean(b);
+                case int i:
+                    return new Integer(i);
+                case string s:
+                    return new String(s);
+                case IEnumerable<object> e:
+                    return new List(e.Select(x => Object.FromBase(x)).ToList());
+                default:
+                    return new Object(o);
+            }
+        }
+        public override object Inner() {
+            return _value;
+        }
+    }
+
+    public class List : Expression {
+        private IList<Expression> _expressions;
+        public List(IList<Expression> expressions) {
+            _expressions = expressions;
+        }
+        public IList<Expression> expressions { get => _expressions; }
+        public override int GetHashCode() {
+            int hash = 17;
+            foreach (Expression i in _expressions) {
+                hash *= 23;
+                hash += i.GetHashCode();
+            }
+            return hash;
+        }
+        public override bool Equals(Expression other) {
+            if (other is List other_l) {
+                return _expressions.SequenceEqual(other_l._expressions);
+            }
+            return false;
+        }
+        public override string ToString() {
+            return "(" + string.Join(" ", _expressions.Select(x => x.ToString())) + ")";
+        }
+        public static List operator +(List a, List b) {
+            List<Expression> r = new List<Expression>();
+            r.AddRange(a.expressions);
+            r.AddRange(b.expressions);
+            return new List(r);
+        }
+        public override object Inner() {
+            return _expressions.Select(x => x.Inner()).ToArray();
+        }
+    }
+
     public class Parser {
         private StringTokenStream _sts;
         public Parser(StringTokenStream tokens) {
@@ -18,16 +280,17 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
                     return parse_grouping(gt, gt.closing_value);
                 case AtomToken at:
                     return parse_atom(at);
+                case OperatorToken ot:
+                    return parse_operator(ot);
                 case SpaceToken sp:
                     return parse();
             }
             return parse();
         }
 
-        Expression parse_string(GroupingToken start, GroupingToken? end) {
+        Expression parse_string(GroupingToken start, GroupingToken end) {
-            Debug.Assert(end != null);
             Debug.Assert(start.value == end.value);
-            Debug.Assert("\"".Contains(start.value));
+            Debug.Assert("'\"".Contains(start.value));
             string r = "";
             while (_sts.Available() > 0) {
                 Token<string> t = _sts.Get();
@@ -40,9 +303,8 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
             return new String(r);
         }
 
-        Expression parse_grouping(GroupingToken start, GroupingToken? end) {
+        Expression parse_grouping(GroupingToken start, GroupingToken end) {
-            Debug.Assert(end != null);
+            if ("'\"".Contains(start.value)) {
-            if ("\"".Contains(start.value)) {
                 return parse_string(start, end);
             }
             IList<Expression> expressions = new List<Expression>();
@@ -55,7 +317,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
                 _sts.Rewind(1);
                 expressions.Add(parse());
             }
-            return Cons.FromList(expressions);
+            return new List(expressions);
         }
 
         Expression parse_atom(AtomToken at) {
@@ -65,13 +327,27 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
                 return new Integer(parsed_value);
             }
             if (at.value.Equals("t")) {
-                return Boolean.TRUE;
+                return new Boolean(true);
             }
             if (at.value.Equals("nil")) {
-                return Boolean.FALSE;
+                return new Boolean(false);
             }
             _sts.Commit();
             return new Symbol(at.value);
         }
+
+        Expression parse_operator(OperatorToken ot) {
+            string v = ot.value;
+            while (_sts.Available() > 0) {
+                Token<string> t = _sts.Get();
+                if (t is OperatorToken ot_) {
+                    v += ot_.value;
+                    continue;
+                }
+                _sts.Rewind(1);
+                break;
+            }
+            return new Symbol(v);
+        }
     }
 }

Jellyfin.Plugin.SmartPlaylist/Lisp/Compiler/TokenStream.cs

@@ -24,13 +24,11 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
     class SpaceToken : Token<string> {
         private SpaceToken(string value) : base(value) {}
         private static IToken<string>? take(CharStream program) {
-            string spaces = " \n";
             if (program.Available() == 0) {
                 return null;
             }
-            var t = program.Get();
+            if (program.Get() == ' ') {
-            if (spaces.Contains(t)) {
+                return new SpaceToken(" ");
-                return new SpaceToken(t.ToString());
             }
             return null;
         }
@@ -43,7 +41,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
                 return null;
             }
             char t = program.Get();
-            if ("()\"".Contains(t)) {
+            if ("()\"'".Contains(t)) {
                 return new GroupingToken(t.ToString());
             }
             return null;
@@ -65,7 +63,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
             string value = "";
             while (program.Available() > 0) {
                 char t = program.Get();
-                if (" \n()\"".Contains(t)) {
+                if (!"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".Contains(t)) {
                     if (value.Equals("")) {
                         return null;
                     }
@@ -78,6 +76,21 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
         }
     }
 
+    class OperatorToken : Token<string> {
+        private OperatorToken(string value) : base(value) {}
+        private static IToken<string>? take(CharStream program) {
+            if (program.Available() == 0) {
+                return null;
+            }
+            return new OperatorToken(program.Get().ToString());
+            //char t = program.get();
+            //if ("+-*/%".Contains(t)) {
+            //    return new OperatorToken(t.ToString());
+            //}
+            //return null;
+        }
+    }
+
     class CharStream: Stream<char> {
         public CharStream(IList<char> items) : base(items) {}
         public CharStream(string items) : base(items.ToCharArray().Cast<char>().ToList()) {}
@@ -88,6 +101,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
             typeof(SpaceToken),
             typeof(GroupingToken),
             typeof(AtomToken),
+            typeof(OperatorToken),
         };
         protected StringTokenStream(IList<Token<string>> tokens) : base(tokens) {}
         private static StringTokenStream generate(CharStream program) {

Jellyfin.Plugin.SmartPlaylist/Lisp/Expression.cs

@@ -1,337 +0,0 @@
-namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
-    interface IAddable<T> where T : IAddable<T> {
-        static abstract T operator +(T left, T right);
-    }
-
-    interface ISubtractable<T> where T : ISubtractable<T> {
-        static abstract T operator -(T left, T right);
-    }
-
-    interface IMultiplicatable<T> where T : IMultiplicatable<T> {
-        static abstract T operator *(T left, T right);
-    }
-
-    interface IDivisible<T> where T : IDivisible<T> {
-        static abstract T operator /(T left, T right);
-        static abstract T operator %(T left, T right);
-    }
-
-    interface ISortable<T, E> where T : ISortable<T, E> {
-        static abstract E operator >(T left, T right);
-        static abstract E operator <(T left, T right);
-        static abstract E operator >=(T left, T right);
-        static abstract E operator <=(T left, T right);
-    }
-
-    interface IComparable<T, E> where T : IComparable<T, E> {
-        static abstract E operator ==(T left, T right);
-        static abstract E operator !=(T left, T right);
-        E Equals(T other);
-    }
-
-    interface IInner {
-        public object Inner();
-    }
-
-    public abstract class Expression: IComparable<Expression, bool> {
-        public override abstract string? ToString();
-        public abstract override int GetHashCode();
-        public abstract bool Equals(Expression other);
-        public override bool Equals(object? other) {
-            if (other is Expression other_e) {
-                return Equals(other_e);
-            }
-            return false;
-        }
-        public static bool operator ==(Expression left, Expression right) {
-            return left.Equals(right);
-        }
-        public static bool operator !=(Expression left, Expression right) {
-            return !left.Equals(right);
-        }
-    }
-
-    public abstract class Atom : Expression {}
-    public class Scalar<V> : Atom, IInner where V : notnull {
-        protected V _value;
-        public Scalar(V value) {
-            _value = value;
-        }
-        public override int GetHashCode() {
-            return 17 * 23 + _value.GetHashCode();
-        }
-        public override bool Equals(Expression other) {
-            if (other is Scalar<V> other_scalar) {
-                return _value.Equals(other_scalar._value);
-            }
-            return false;
-        }
-        public override string? ToString() {
-            return _value.ToString();
-        }
-        public V Value() {
-            return _value;
-        }
-        public object Inner() {
-            return _value;
-        }
-    }
-    public class Symbol : Atom {
-        private string _name;
-        public Symbol(string name) {
-            _name = name;
-        }
-        public override int GetHashCode() {
-            return 17 * 23 + _name.GetHashCode();
-        }
-        public override bool Equals(Expression other) {
-            if (other is Symbol other_symbol) {
-                return _name.Equals(other_symbol._name);
-            }
-            return false;
-        }
-        public override string? ToString() {
-            return _name.ToString();
-        }
-        public string Name() {
-            return _name;
-        }
-    }
-    public class Integer : Scalar<int>, IAddable<Integer>, ISubtractable<Integer>, IMultiplicatable<Integer>, IDivisible<Integer>, ISortable<Integer, Boolean> {
-        public Integer(int value) : base(value) {}
-        public static Integer operator +(Integer a, Integer b) {
-            return new Integer(a._value + b._value);
-        }
-        public static Integer operator -(Integer a, Integer b) {
-            return new Integer(a._value - b._value);
-        }
-        public static Integer operator *(Integer a, Integer b) {
-            return new Integer(a._value * b._value);
-        }
-        public static Integer operator /(Integer a, Integer b) {
-            return new Integer(a._value / b._value);
-        }
-        public static Integer operator %(Integer a, Integer b) {
-            return new Integer(a._value % b._value);
-        }
-        public static Boolean operator >(Integer a, Integer b) {
-            return (a._value > b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public static Boolean operator <(Integer a, Integer b) {
-            return (a._value < b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public static Boolean operator >=(Integer a, Integer b) {
-            return (a._value >= b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public static Boolean operator <=(Integer a, Integer b) {
-            return (a._value <= b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public override int GetHashCode() {
-            return base.GetHashCode();
-        }
-        public override bool Equals(object? other) {
-            return base.Equals(other);
-        }
-        public static Boolean operator ==(Integer a, Integer b) {
-            return (a._value == b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public static Boolean operator !=(Integer a, Integer b) {
-            return (a._value != b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-    }
-
-    public class Boolean: Scalar<bool> {
-        public static Boolean TRUE = new Boolean(true);
-        public static Boolean FALSE = new Boolean(false);
-        private Boolean(bool value) : base(value) {}
-        public override string? ToString() {
-            if (_value) {
-                return "t";
-            }
-            return "nil";
-        }
-        public IList<Expression> ToList() {
-            if (_value) {
-                throw new ApplicationException("Cannot use t as list");
-            }
-            return new List<Expression>();
-        }
-    }
-    public class String: Scalar<string>, ISortable<String, Boolean> {
-        public String(string value) : base(value) {}
-        public override string? ToString() {
-            return $"\"{base.ToString()}\"";
-        }
-        public static Boolean operator <(String a, String b) {
-            return (a.Value().CompareTo(b.Value()) < 0) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public static Boolean operator >(String a, String b) {
-            return b < a;
-        }
-        public static Boolean operator <=(String a, String b) {
-            return (a.Value().CompareTo(b.Value()) <= 0) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public static Boolean operator >=(String a, String b) {
-            return b <= a;
-        }
-        public override int GetHashCode() {
-            return base.GetHashCode();
-        }
-        public override bool Equals(object? other) {
-            return base.Equals(other);
-        }
-        public static Boolean operator ==(String a, String b) {
-            return (a._value == b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-        public static Boolean operator !=(String a, String b) {
-            return (a._value != b._value) ? Boolean.TRUE : Boolean.FALSE;
-        }
-    }
-    public class Cons: Expression {
-        public Expression Item1;
-        public Expression Item2;
-        public Cons(Expression item1, Expression item2) {
-            Item1 = item1;
-            Item2 = item2;
-        }
-        public static Expression FromList(IEnumerable<Expression> expressions) {
-            var e = expressions.ToList();
-            if (e.Count == 0) {
-                return Boolean.FALSE;
-            }
-            var item1 = expressions.First();
-            if (e.Count == 1) {
-                return new Cons(item1, Boolean.FALSE);
-            }
-            var item2 = expressions.Skip(1).ToList();
-            return new Cons(item1, FromList(item2));
-        }
-        public IEnumerable<Expression> ToList() {
-            var l = new List<Expression>();
-            l.Add(Item1);
-            if (Item2 == Boolean.FALSE) {
-                return l;
-            }
-            if (Item2 is Cons item2_cons) {
-                l.AddRange(item2_cons.ToList());
-                return l;
-            }
-            l.Add(Item2);
-            return l;
-        }
-        public override int GetHashCode() {
-            var hash = 17;
-            hash *= 23;
-            hash += Item1.GetHashCode();
-            hash *= 23;
-            hash += Item2.GetHashCode();
-            return hash;
-        }
-        public override bool Equals(Expression other) {
-            if (other is Cons other_list) {
-                return Item1.Equals(other_list.Item1) && Item2.Equals(other_list.Item2);
-            }
-            return false;
-        }
-        private string? ToStringSimple() {
-            if (Item2.Equals(Boolean.FALSE)) {
-                return Item1.ToString();
-            }
-            if (Item2 is Cons item2_cons) {
-                return $"{Item1} {item2_cons.ToStringSimple()}";
-            }
-            return $"{Item1} . {Item2}";
-        }
-        public override string? ToString() {
-            return $"({ToStringSimple()})";
-        }
-    }
-
-    public class Object : Scalar<object> {
-        internal Object(object value) : base(value) {}
-        public static Expression FromBase(object? o) {
-            if (o == null) {
-                return Boolean.FALSE;
-            }
-            switch (o) {
-                case bool b:
-                    return b ? Boolean.TRUE : Boolean.FALSE;
-                case int i:
-                    return new Integer(i);
-                case string s:
-                    return new String(s);
-                case Expression e:
-                    return e;
-                case IEnumerable<object> e:
-                    return Cons.FromList(e.Select(x => FromBase(x)));
-                default:
-                    return new Object(o);
-            }
-        }
-    }
-
-    public class Procedure : Expression {
-        private IEnumerable<Symbol> _parameters;
-        private Expression _body;
-        private bool _eval_args;
-        public Procedure(IEnumerable<Symbol> parameters, Expression body, bool eval_args) {
-            _parameters = parameters;
-            _body = body;
-            _eval_args = eval_args;
-        }
-        public override int GetHashCode() {
-            int hash = 17;
-            hash *= 23;
-            hash += _parameters.GetHashCode();
-            hash *= 23;
-            hash += _body.GetHashCode();
-            return hash;
-        }
-        public override bool Equals(Expression? other) {
-            if (other is Procedure other_p) {
-                return _parameters == other_p._parameters && _body == other_p._body;
-            }
-            return false;
-        }
-        public override string ToString() {
-            var star = _eval_args ? "" : "*";
-            return $"(lambda{star} {Cons.FromList(_parameters)} {_body})";
-        }
-
-        private Expression __eval(Executor e, Expression exp) {
-            if (!_eval_args) return exp;
-            return e.eval(exp);
-        }
-
-        private Expression _eval(Executor e, Expression exp) {
-            var r = __eval(e, exp);
-            //Console.WriteLine($"{exp} = {r}");
-            return r;
-        }
-
-        public Expression Call(Executor e, IList<Expression> args) {
-            Executor new_e = new Executor(new SubEnvironment(e.environment), e.builtins, e.builtinsLater);
-            var _params = _parameters.Select(x => x.Name()).ToArray();
-            var idx_rest = -1;
-
-            IList<(string, Expression)> name_args = new List<(string, Expression)>();
-            for (var i = 0; i < _parameters.Count(); i++) {
-                var name = _params[i];
-                if (name.Equals(".")) {
-                    idx_rest = i + 1;
-                    break;
-                }
-                name_args.Add((name, _eval(e, args[i])));
-            }
-            if (idx_rest > 0) {
-                name_args.Add((_params[idx_rest], Cons.FromList(args.Skip(idx_rest - 1).Select(x => _eval(e, x)))));
-            }
-            foreach (var na in name_args) {
-                new_e.environment.Set(na.Item1, na.Item2);
-            }
-            var r = new_e.eval(_body);
-            return r;
-        }
-    }
-
-}

Jellyfin.Plugin.SmartPlaylist/Lisp/Interpreter.cs

@@ -3,19 +3,63 @@ using System.Reflection;
 using Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler;
 
 namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
-    using Function = Func<IEnumerable<Expression>, Expression>;
+    using Function = Func<IList<Expression>, Expression>;
-    using FunctionLater = Func<Executor, IEnumerable<Expression>, Expression>;
+    using FunctionLater = Func<Executor, IList<Expression>, Expression>;
+
+    public class Procedure : Expression {
+        private Compiler.List _parameters;
+        private Expression _body;
+        public Procedure(Compiler.List parameters, Expression body) {
+            _parameters = parameters;
+            _body = body;
+        }
+        private static IEnumerable<(T1, T2)> Zip<T1, T2>(IEnumerable<T1> a, IEnumerable<T2> b) {
+            using (var e1 = a.GetEnumerator()) using (var e2 = b.GetEnumerator()) {
+                while (e1.MoveNext() && e2.MoveNext()) {
+                    yield return (e1.Current, e2.Current);
+                }
+            }
+        }
+        public override int GetHashCode() {
+            int hash = 17;
+            hash *= 23;
+            hash += _parameters.GetHashCode();
+            hash *= 23;
+            hash += _body.GetHashCode();
+            return hash;
+        }
+        public override bool Equals(Expression? other) {
+            if (other is Procedure other_p) {
+                return _parameters == other_p._parameters && _body == other_p._body;
+            }
+            return false;
+        }
+        public override object Inner() {
+            throw new ApplicationException("This is not sensible");
+        }
+        public override string ToString() {
+            return $"(lambda {_parameters} {_body})";
+        }
+
+        public Expression Call(Executor e, IList<Expression> args) {
+            var p = _parameters.expressions.Select(x => x.Inner().ToString()).ToList();
+            Executor new_e = new Executor(new SubEnvironment(e.environment), e.builtins, e.builtinsLater);
+            foreach (var tuple in Zip<string, Expression>(p, args)) {
+                new_e.environment.Set(tuple.Item1, tuple.Item2);
+            }
+            return new_e.eval(_body);
+        }
+    }
 
     public interface IEnvironment<K, V> {
-        public V? Get(K k);
+        public V Get(K k);
         public void Set(K k, V v);
         public IEnvironment<K, V>? Find(K k);
-        public IEnvironment<K, V> Parent(bool recursive);
     }
 
     public class Environment : Dictionary<string, Expression>, IEnvironment<string, Expression> {
         public Expression? Get(string k) {
-            if (TryGetValue(k, out Expression? v)) {
+            if (TryGetValue(k, out Expression v)) {
                 return v;
             }
             return null;
@@ -30,54 +74,11 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
             }
             return null;
         }
-
-        public IEnvironment<string, Expression> Parent(bool recursive) {
-            return this;
-        }
     }
 
     public class DefaultEnvironment: Environment {
         public DefaultEnvironment() {
-            var e = new Executor();
+            this["find"] = new Parser("(lambda (item list) (if (= list ()) nil (if (= item (car list)) (car list) (find item (cdr list)))))").parse();
-            this["null"] = new Symbol("not");
-            this["list"] = e.eval("(lambda (. args) args)");
-            this["find"] = e.eval("(lambda (item list_) (if (null list_) nil (if (= item (car list_)) (car list_) (find item (cdr list_)))))");
-            this["map"] = e.eval("(lambda (fc l) (if (null l) nil (cons (fc (car l)) (map fc (cdr l)))))");
-            this["fold"] = e.eval("(lambda (fc i l) (if (null l) i (fold fc (fc i (car l)) (cdr l))))");
-            this["any"] = e.eval("(lambda (fc l) (apply or (map fc l)))");
-            this["all"] = e.eval("(lambda (fc l) (apply and (map fc l)))");
-            this["append"] = e.eval("(lambda (l i) (if (null l) i (cons (car l) (append (cdr l) i))))");
-            this["qsort"] = e.eval(
-                """
-                (lambda
-                  (fc list00)
-                  (let
-                    (getpivot
-                      (lambda
-                        (list0)
-                        (car list0)))
-                    (split
-                      (lambda
-                        (list0 pivot fc h0 h1)
-                        (cond
-                          ((null list0) (list list0 pivot fc h0 h1))
-                          ((fc (car list0) pivot) (split (cdr list0) pivot fc h0 (cons (car list0) h1)))
-                          (t (split (cdr list0) pivot fc (cons (car list0) h0) h1)))))
-                    (sort
-                      (lambda
-                        (fc list0)
-                        (cond
-                          ((null list0) nil)
-                          ((null (cdr list0)) list0)
-                          (t
-                            (let*
-                              (halves (split list0 (getpivot list0) fc nil nil))
-                              (h0 (car (cdr (cdr (cdr halves)))))
-                              (h1 (car (cdr (cdr (cdr (cdr halves))))))
-                              (append (sort fc h0) (sort fc h1)))))))
-                    (sort fc list00)))
-                """
-            );
         }
     }
 
@@ -87,7 +88,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
             _super = super;
         }
         public Expression? Get(string k) {
-            if (TryGetValue(k, out Expression? v)) {
+            if (TryGetValue(k, out Expression v)) {
                 return v;
             }
             return null;
@@ -102,275 +103,272 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
             }
             return _super.Find(k);
         }
-
-        public IEnvironment<string, Expression> Parent(bool recursive) {
-            if (recursive) {
-                return this._super.Parent(recursive);
-            }
-            return this._super;
-        }
     }
 
     public class Builtins : Dictionary<string, Function> {
         public Builtins() : base() {
-            this["atom"] = _atom;
+            this["+"] = _add;
-            this["eq"] = _eq;
+            this["-"] = _sub;
+            this["*"] = _mul;
+            this["/"] = _div;
+            this["%"] = _mod;
+            this[">"] = _gt;
+            this["<"] = _lt;
+            this[">="] = _ge;
+            this["<="] = _le;
+            this["eq?"] = _eq;
+            this["="] = _eq;
+            this["!="] = _ne;
+            this["abs"] = _abs;
+            this["append"] = _append;
+            this["begin"] = _begin;
             this["car"] = _car;
             this["cdr"] = _cdr;
             this["cons"] = _cons;
-
+            this["not"] = _not;
-            this["begin"] = _begin;
+            this["length"] = _length;
-
-            this["+"] = (x) => _agg((Integer a, Integer b) => a + b, x);
-            this["-"] = (x) => _agg((Integer a, Integer b) => a - b, x);
-            this["*"] = (x) => _agg((Integer a, Integer b) => a * b, x);
-            this["/"] = (x) => _agg((Integer a, Integer b) => a / b, x);
-            this["%"] = (x) => _agg((Integer a, Integer b) => a % b, x);
-
-            this["="] = (x) => _cmp((Atom a, Atom b) => (a == b)? Boolean.TRUE : Boolean.FALSE, x);
-            this["!="] = (x) => _cmp((Atom a, Atom b) => (a != b)? Boolean.TRUE : Boolean.FALSE, x);
-            this["<"] = (x) => _cmp((Integer a, Integer b) => a < b, x);
-            this["<="] = (x) => _cmp((Integer a, Integer b) => a <= b, x);
-            this[">"] = (x) => _cmp((Integer a, Integer b) => a > b, x);
-            this[">="] = (x) => _cmp((Integer a, Integer b) => a >= b, x);
-            this["not"] = (x) => {
-                return (x.First() == Boolean.FALSE) ? Boolean.TRUE : Boolean.FALSE;
-            };
-            this["string="] = (x) => _cmp((String a, String b) => a == b, x);
-            this["string!="] = (x) => _cmp((String a, String b) => a != b, x);
-            this["string>"] = (x) => _cmp((String a, String b) => a > b, x);
-            this["string>="] = (x) => _cmp((String a, String b) => a >= b, x);
-            this["string<"] = (x) => _cmp((String a, String b) => a < b, x);
-            this["string<="] = (x) => _cmp((String a, String b) => a <= b, x);
-
-
             this["haskeys"] = _haskeys;
             this["getitems"] = _getitems;
             this["invoke"] = _invoke;
         }
-        private static T _agg<T>(Func<T, T, T> op, IEnumerable<Expression> args) where T : Expression {
+
-            T agg = (T) args.First();
+        private static T _agg<T>(Func<T, T, T> op, IList<T> args) {
+            T agg = args[0];
             foreach (var arg in args.Skip(1)) {
-                var arg_ = (T) arg;
+                agg = op(agg, arg);
-                agg = op(agg, arg_);
             }
             return agg;
         }
-        private static E _cmp<T, E>(Func<T, T, E> op, IEnumerable<Expression> args) where T : Expression where E : Expression {
+        private static Expression _add(IList<Expression> args) {
-            return op((T) args.First(), (T) args.Skip(1).First());
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _agg((a, b) => a + b, args.Select(x => (Integer) x).ToList());
+                case Compiler.String s:
+                    return _agg((a, b) => a + b, args.Select(x => (Compiler.String) x).ToList());
+            }
+            throw new ApplicationException();
         }
-        private static Expression _atom(IEnumerable<Expression> args) {
+        private static Expression _sub(IList<Expression> args) {
-            return (args.First() is Atom) ? Boolean.TRUE : Boolean.FALSE;
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _agg((a, b) => a - b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
         }
-        private static Expression _eq(IEnumerable<Expression> args) {
+        private static Expression _mul(IList<Expression> args) {
-            return args.First().Equals(args.Skip(1).First()) ? Boolean.TRUE : Boolean.FALSE;
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _agg((a, b) => a * b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
         }
-        private static Expression _car(IEnumerable<Expression> args) {
+        private static Expression _div(IList<Expression> args) {
-            return ((Cons)args.First()).Item1;
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _agg((a, b) => a / b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
         }
-        private static Expression _cdr(IEnumerable<Expression> args) {
+        private static Expression _mod(IList<Expression> args) {
-            return ((Cons)args.First()).Item2;
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _agg((a, b) => a % b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
         }
-        private static Expression _cons(IEnumerable<Expression> args) {
+        private static E _cmp<T, E>(Func<T, T, E> op, IList<T> args) {
-            return new Cons(args.First(), args.Skip(1).First());
+            T first = args[0];
+            T second = args[1];
+            return op(first, second);
         }
-        private static Expression _begin(IEnumerable<Expression> args) {
+        private static Expression _gt(IList<Expression> args) {
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _cmp((a, b) => a > b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
+        }
+        private static Expression _lt(IList<Expression> args) {
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _cmp((a, b) => a < b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
+        }
+        private static Expression _ge(IList<Expression> args) {
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _cmp((a, b) => a >= b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
+        }
+        private static Expression _le(IList<Expression> args) {
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return _cmp((a, b) => a <= b, args.Select(x => (Integer) x).ToList());
+            }
+            throw new ApplicationException();
+        }
+        private static Expression _eq(IList<Expression> args) {
+            bool r = _cmp((a, b) => a == b, args);
+            return new Compiler.Boolean(r);
+        }
+        private static Expression _ne(IList<Expression> args) {
+            bool r = _cmp((a, b) => a != b, args);
+            return new Compiler.Boolean(r);
+        }
+        private static Expression _abs(IList<Expression> args) {
+            Expression first = args[0];
+            switch (first) {
+                case Integer i:
+                    return i.value >= 0 ? i : new Integer(-i.value);
+            }
+            throw new ApplicationException();
+        }
+        private static Expression _append(IList<Expression> args) {
+            Expression first = args[0];
+            switch (first) {
+                case List l:
+                    return l + new List(args);
+            }
+            throw new ApplicationException();
+        }
+        private static Expression _begin(IList<Expression> args) {
             return args.Last();
         }
-        private static Expression _haskeys(IEnumerable<Expression> args) {
+        private static Expression _car(IList<Expression> args) {
-            Object o = new Object(((IInner) args.First()).Inner());
+            return ((List) args.First()).expressions.First();
+        }
+        private static Expression _cdr(IList<Expression> args) {
+            return new List(((List) args.First()).expressions.Skip(1).ToList());
+        }
+        private static Expression _cons(IList<Expression> args) {
+            switch (args[1]) {
+                case Compiler.List other_list:
+                    return (new Compiler.List(new []{args[0]}.ToList()) + new Compiler.List(other_list.expressions));
+                case Atom other_atom:
+                    return new Compiler.List(new[]{args[0], args[1]}.ToList());
+            }
+            throw new ApplicationException();
+        }
+        private static Expression _not(IList<Expression> args) {
+            if (args[0] == new Compiler.Boolean(false)) {
+                return new Compiler.Boolean(true);
+            }
+            return new Compiler.Boolean(false);
+        }
+        private static Expression _length(IList<Expression> args) {
+            return new Integer(((Compiler.List)args[0]).expressions.Count());
+        }
+        private static Expression _haskeys(IList<Expression> args) {
+            Compiler.Object o = (Compiler.Object) args[0];
             foreach (var e in args.Skip(1)) {
-                String s = (String) e;
+                Compiler.String s = (Compiler.String) e;
-                PropertyInfo? pi = o.Value().GetType().GetProperty(s.Value());
+                PropertyInfo? pi = o.value.GetType().GetProperty(s.value);
                 if (pi != null) {
                     continue;
                 }
-                MethodInfo? mi = o.Value().GetType().GetMethod(s.Value());
+                MethodInfo? mi = o.value.GetType().GetMethod(s.value);
                 if (mi != null) {
                     continue;
                 }
-                FieldInfo? fi = o.Value().GetType().GetField(s.Value());
+                FieldInfo? fi = o.value.GetType().GetField(s.value);
                 if (fi != null) {
                     continue;
                 }
-                return Boolean.FALSE;
+                return new Compiler.Boolean(false);
             }
-            return Boolean.TRUE;
+            return new Compiler.Boolean(true);
         }
-        private static Expression _getitems(IEnumerable<Expression> args) {
+        private static Expression _getitems(IList<Expression> args) {
-            Object o = new Object(((IInner) args.First()).Inner());
+            Compiler.Object o = (Compiler.Object) args[0];
             IList<Expression> r = new List<Expression>();
             foreach (var e in args.Skip(1)) {
-                String s = (String) e;
+                Compiler.String s = (Compiler.String) e;
-                PropertyInfo? pi = o.Value().GetType().GetProperty(s.Value());
+                PropertyInfo? pi = o.value.GetType().GetProperty(s.value);
                 if (pi != null) {
-                    r.Add(Object.FromBase(pi.GetValue(o.Value())));
+                    r.Add(Compiler.Object.FromBase(pi.GetValue(o.value)));
                     continue;
                 }
-                FieldInfo? fi = o.Value().GetType().GetField(s.Value());
+                FieldInfo? fi = o.value.GetType().GetField(s.value);
                 if (fi != null) {
-                    r.Add(Object.FromBase(fi.GetValue(o.Value())));
+                    r.Add(Compiler.Object.FromBase(fi.GetValue(o.value)));
                     continue;
                 }
-                throw new ApplicationException($"{o.Value()} has no property or field {s.Value()}");
+                throw new ApplicationException($"{o.value} has no property or field {s.value}");
             }
-            return Cons.FromList(r);
+            return new Compiler.List(r);
         }
 
-        private static Expression _invoke(IEnumerable<Expression> args) {
+        private static Expression _invoke(IList<Expression> args) {
-            Object o = new Object(((IInner) args.First()).Inner());
+            Compiler.Object o = (Compiler.Object) args[0];
-            String s = (String) args.Skip(1).First();
+            Compiler.String s = (Compiler.String) args[1];
-            IEnumerable<Expression> l;
+            Compiler.List l = (Compiler.List) args[2];
-            if (args.Skip(2).First() is Boolean lb && lb == Boolean.FALSE) {
-                l = new List<Expression>();
-            } else if (args.Skip(2).First() is Cons lc) {
-                l = lc.ToList();
-            } else {
-                throw new ApplicationException($"Expected a list of arguments, got {args.Skip(2).First()}");
-            }
-            object[]? l_ = l.Select<Expression, object>(x => {
-                switch (x) {
-                    case Integer s:
-                        return s.Value();
-                    case Boolean b:
-                        return b.Value();
-                    case String s:
-                        return s.Value();
-                    case Object o:
-                        return o.Value();
-                    case Cons c:
-                        return c.ToList().ToList();
-                }
-                throw new ApplicationException($"Unhandled value {x} (type {x.GetType()})");
-            }).ToArray();
-            Type[] l_types = l_.Select( x => {
-                    return x.GetType();
-            }).ToArray();
-
             IList<Expression> r = new List<Expression>();
-            MethodInfo? mi = o.Value().GetType().GetMethod(s.Value(), l_types);
+            MethodInfo? mi = o.value.GetType().GetMethod(s.value);
             if (mi == null) {
-                throw new ApplicationException($"{o.Value()} has not method {s.Value()}");
+                throw new ApplicationException($"{o.value} has not method {s.value}");
             }
-
+            return Compiler.Object.FromBase(mi.Invoke(o.value, (object?[]?) l.Inner()));
-            return Object.FromBase(mi.Invoke(o.Value(), l_));
         }
     }
 
     public class BuiltinsLater : Dictionary<string, FunctionLater> {
         public BuiltinsLater() : base() {
-            this["quote"] = _quote;
-            this["eval"] = _eval;
-            this["cond"] = _cond;
             this["if"] = _if;
             this["define"] = _define;
-            this["let"] = _let;
-            this["let*"] = _let_star;
             this["lambda"] = _lambda;
-            this["lambda*"] = _lambda_star;
             this["apply"] = _apply;
-
+            this["and"] = _and;
-            this["and"] = (e, x) => {
+            this["or"] = _or;
-                Expression? r = null;
-                foreach (var xi in x) {
-                    r = e.eval(xi);
-                    if (r == Boolean.FALSE) {
-                        return r;
-                    }
-                }
-                if (r is null) {
-                    return Boolean.FALSE;
-                }
-                return r;
-            };
-            this["or"] = (e, x) => {
-                foreach (var xi in x) {
-                    var r = e.eval(xi);
-                    if (r != Boolean.FALSE) {
-                        return r;
-                    }
-                }
-                return Boolean.FALSE;
-            };
         }
-        private static Expression _quote(Executor e, IEnumerable<Expression> args) {
+        private static Expression _if(Executor e, IList<Expression> args) {
-            return args.First();
+            bool test = e.eval(args[0]) != (new Compiler.Boolean(false));
+            return e.eval(args[1 + (test ? 0 : 1)]);
         }
-        private static Expression _eval(Executor e, IEnumerable<Expression> args) {
+        private static Expression _define(Executor e, IList<Expression> args) {
-            return e.eval(e.eval(args.First()));
+            var refname = ((Symbol) args[0]).name;
+            e.environment.Set(refname, e.eval(args[1]));
+            return new Compiler.Boolean(false); // NOOP
         }
-        private static Expression _cond(Executor e, IEnumerable<Expression> args) {
+        private static Expression _lambda(Executor e, IList<Expression> args) {
-            foreach (var a in args) {
+            return new Procedure((Compiler.List) args[0], args[1]);
-                if (a is Cons a_cons) {
+        }
-                    var a_ = a_cons.ToList();
+        private static Expression _apply(Executor e, IList<Expression> args) {
-                    if (!e.eval(a_.First()).Equals(Boolean.FALSE)) {
+            if (args[0].GetType() != typeof(Symbol)) {
-                        return e.eval(a_.Skip(1).First());
+                throw new ApplicationException();
-                    }
-                } else {
-                    throw new ApplicationException($"Incorrect arguments to cond, expected list: {args}");
-                }
             }
-            return Boolean.FALSE;
+            if (args[1].GetType() != typeof(List)) {
-        }
+                throw new ApplicationException();
-        private static Expression _if(Executor e, IEnumerable<Expression> args) {
-            if (e.eval(args.First()).Equals(Boolean.FALSE)) {
-                return e.eval(args.Skip(2).First());
             }
-            return e.eval(args.Skip(1).First());
+            Symbol arg0 = (Compiler.Symbol) args[0];
+            Compiler.List other_args = (Compiler.List) args[1];
+            return e.EvalFunction(arg0, other_args.expressions);
         }
-        private static Expression _define(Executor e, IEnumerable<Expression> args) {
+        private static Expression _and(Executor e, IList<Expression> args) {
-            Symbol refname = (Symbol) args.First();
+            Expression result = new Compiler.Boolean(false);
-            e.environment.Parent(true).Set(refname.Name(), args.Skip(1).Select(x => e.eval(x)).First());
+            foreach (var exp in args) {
-            return Boolean.TRUE;
+                result = e.eval(exp);
-        }
+                if (result == new Compiler.Boolean(false)) { return result; }
-        private static Expression _let_star(Executor e, IEnumerable<Expression> args) {
-            Executor new_e = new Executor(new SubEnvironment(e.environment), e.builtins, e.builtinsLater);
-            foreach (var pair in args.SkipLast(1)) {
-                if (pair is not Cons pair_cons) {
-                    throw new ApplicationException("No expression for let*");
-                }
-                Symbol refname = (Symbol) pair_cons.Item1;
-                Expression exp = ((Cons) pair_cons.Item2).Item1;
-                new_e.environment.Set(refname.Name(), new_e.eval(exp));
             }
-            return new_e.eval(args.Last());
+            return result;
         }
-        private static Expression _let(Executor e, IEnumerable<Expression> args) {
+        private static Expression _or(Executor e, IList<Expression> args) {
-            Executor new_e = new Executor(new SubEnvironment(e.environment), e.builtins, e.builtinsLater);
+            Expression result = new Compiler.Boolean(false);
-            List<(Symbol, Expression)> vars = new List<(Symbol, Expression)>();
+            foreach (var exp in args) {
-            foreach (var pair in args.SkipLast(1)) {
+                result = e.eval(exp);
-                if (pair is not Cons pair_cons) {
+                if (result != new Compiler.Boolean(false)) { return result; }
-                    throw new ApplicationException("");
-                }
-                Symbol refname = (Symbol) pair_cons.Item1;
-                Expression exp_ = ((Cons) pair_cons.Item2).Item1;
-                vars.Add((refname, e.eval(exp_)));
             }
-            foreach (var pair in vars) {
+            return result;
-                new_e.environment.Set(pair.Item1.Name(), pair.Item2);
-            }
-            return new_e.eval(args.Last());
-        }
-        private static Expression _lambda(Executor e, IEnumerable<Expression> args) {
-            IEnumerable<Symbol> proc_args;
-            if (args.First() is Cons proc_args_) { proc_args = proc_args_.ToList().Select(x => (Symbol) x); }
-            else if (args.First() == Boolean.FALSE) { proc_args = new List<Symbol>(); }
-            else {
-                throw new ApplicationException("");
-            }
-            return new Procedure(proc_args, args.Skip(1).First(), true);
-        }
-        private static Expression _lambda_star(Executor e, IEnumerable<Expression> args) {
-            IEnumerable<Symbol> proc_args;
-            if (args.First() is Cons proc_args_) { proc_args = proc_args_.ToList().Select(x => (Symbol) x); }
-            else if (args.First() == Boolean.FALSE) { proc_args = new List<Symbol>(); }
-            else {
-                throw new ApplicationException("");
-            }
-            return new Procedure(proc_args, args.Skip(1).First(), false);
-        }
-        private static Expression _apply(Executor e, IEnumerable<Expression> args) {
-            return e.eval(new Cons(args.First(), e.eval(args.Skip(1).First())));
         }
     }
 
@@ -398,52 +396,54 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
         public Builtins builtins { get => _builtins; }
         public BuiltinsLater builtinsLater { get => _builtinsLater; }
 
-        public Expression? EvalFunction(Symbol fcname, IEnumerable<Expression> args) {
+        public Expression EvalFunction(Symbol fcname, IList<Expression> args) {
-            if (builtins.ContainsKey(fcname.Name())) {
+            if (_environment.Find(fcname.name) is IEnvironment<string, Expression> _e) {
-                return builtins[fcname.Name()](args.Select(x => eval(x)).ToList()); // call ToList for sideeffect
+                Expression? first = _e.Get(fcname.name);
+                return new List(new []{first}.ToList()) + new List(args.Select(x => eval(x)).ToList());
             }
-            if (builtinsLater.ContainsKey(fcname.Name())) {
+            if (_builtins.ContainsKey(fcname.name)) {
-                return builtinsLater[fcname.Name()](this, args);
+                Function fc = _builtins[fcname.name];
+                return fc(args.Select(x => eval(x)).ToList());
             }
-            return null;
+            if (_builtinsLater.ContainsKey(fcname.name)) {
+                FunctionLater fc = _builtinsLater[fcname.name];
+                return fc(this, args);
+            }
+            throw new ApplicationException($"Key '{fcname.name}' not found in environment or builtins");
+
         }
 
         public Expression eval(Expression expression) {
             switch (expression) {
                 case Symbol s:
-                    if (_environment.Find(s.Name()) is not IEnvironment<string, Expression> env) {
+                    return _environment.Find(s.name).Get(s.name);
-                        throw new ApplicationException($"Could not find '{s.Name()}'");
+                case Compiler.Boolean b:
-                    }
-                    var r_ = env.Get(s.Name());
-                    if (r_ is null) {
-                        throw new ApplicationException($"Could not find '{s.Name()}'");
-                    }
-                    return r_;
-                case Boolean b:
                     return b;
                 case Integer i:
                     return i;
-                case String s:
+                case Compiler.String s:
                     return s;
-                case Object o:
+                case Compiler.Object o:
                     return o;
                 case Procedure p:
                     return p;
-                case Cons cons:
+                case List list:
-                    var l = cons.ToList();
+                    if (list.expressions.Count == 0) {
-                    if (cons.Item1 is Symbol cons_item1_symbol) {
+                        return list;
-                        Expression? r = EvalFunction(cons_item1_symbol, l.Skip(1));
-                        if (r is not null) { return r; }
                     }
-                    var eval_Item1 = eval(cons.Item1);
+                    // do we really want to allow shadowing of builtins?
-                    if (eval_Item1 is Symbol eval_item1_symbol1) {
+                    if (list.expressions[0].GetType() == typeof(Symbol)) {
-                        Expression? r = EvalFunction(eval_item1_symbol1, l.Skip(1));
+                        return eval(EvalFunction((Symbol) list.expressions[0], list.expressions.Skip(1).ToList()));
-                        if (r is not null) { return r; }
                     }
-                    if (eval_Item1 is Procedure eval_item1_procedure) {
+                    if (list.expressions[0].GetType() == typeof(Procedure)) {
-                        return eval_item1_procedure.Call(this, l.Skip(1).Select(x => x).ToList());
+                        Procedure procedure = (Procedure) list.expressions[0];
+                        return eval(procedure.Call(this, list.expressions.Skip(1).ToList()));
                     }
-                    throw new ApplicationException($"Not handled case (type = {eval_Item1.GetType()}) '{cons}'");
+                    var l = new List(list.expressions.Select(x => eval(x)).ToList());
+                    if (l.expressions[0].GetType() == typeof(Procedure)) {
+                        return eval(l);
+                    }
+                    return l;
             }
             throw new ApplicationException($"Not handled case '{expression}'");
         }

Jellyfin.Plugin.SmartPlaylist/Plugin.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using System.Globalization;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Plugins;

Jellyfin.Plugin.SmartPlaylist/PluginConfiguration.cs

@@ -1,43 +1,14 @@
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Plugins;
 using MediaBrowser.Model.Plugins;
+using MediaBrowser.Model.Serialization;
 
 namespace Jellyfin.Plugin.SmartPlaylist {
     public class PluginConfiguration : BasePluginConfiguration {
-        public PluginConfiguration() {
+        public PluginConfiguration(
-            InitialProgram = """
+        ) {
-            (begin
-              (define lower
-                (lambda (s)
-                  (invoke s "ToLower" nil)))
-              (define is-genre
-                (lambda (g g-list)
-                  (any
-                    (lambda (x)
-                      (invoke (lower x) "Contains" (list (lower g))))
-                    g-list)))
-              (define is-genre-exact
-                (lambda (g g-list)
-                  (find g g-list)))
-              (define genre-list
-                (lambda nil
-                  (let
-                    (_g (getitems item "Genres"))
-                    (if (null _g)
-                      nil
-                      (car _g)))))
-              (define is-favorite
-                (lambda nil
-                  (invoke item "IsFavoriteOrLiked" (list user))))
-              (define is-type
-                (lambda (x)
-                  (and
-                    (haskeys item "GetClientTypeName")
-                    (invoke (invoke item "GetClientTypeName" nil) "Equals" (list x)))))
-              (define name-contains
-                (lambda (x)
-                  (invoke (lower (car (getitems item "Name"))) "Contains" (list (lower x)))))
-              (define is-favourite is-favorite))
-            """;
         }
-        public string InitialProgram { get; set; }
     }
 }

Jellyfin.Plugin.SmartPlaylist/ScheduledTasks/GeneratePlaylist.cs

@@ -1,4 +1,3 @@
-using System.Globalization;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
 using MediaBrowser.Controller;
@@ -6,16 +5,28 @@ using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.IO;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Jellyfin.Data.Entities;
 using Jellyfin.Data.Enums;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Controller;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Playlists;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
 
 using Jellyfin.Plugin.SmartPlaylist.Lisp;
 using Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler;
-using Lisp_Object = Jellyfin.Plugin.SmartPlaylist.Lisp.Object;
+using Lisp_Object = Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler.Object;
-using Lisp_Boolean = Jellyfin.Plugin.SmartPlaylist.Lisp.Boolean;
+using Lisp_Boolean = Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler.Boolean;
 
 
 namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
@@ -82,7 +93,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
             }
         }
 
-        private PlaylistId CreateNewPlaylist(string name, UserId userId) {
+        private SmartPlaylistId CreateNewPlaylist(string name, UserId userId) {
             _logger.LogDebug("Creating playlist '{0}'", name);
             var req = new PlaylistCreationRequest {
                 Name = name,
@@ -95,42 +106,20 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
         }
 
         private IEnumerable<Guid> FilterPlaylistItems(IEnumerable<BaseItem> items, User user, SmartPlaylistDto smartPlaylist) {
-            List<BaseItem> results = new List<BaseItem>();
+            List<Guid> results = new List<Guid>();
-            Expression expression = new Parser(StringTokenStream.generate(smartPlaylist.Program)).parse(); // parse here, so that we don't repeat the work for each item
+            Expression expression = new Parser(StringTokenStream.generate(smartPlaylist.Program)).parse();
             Executor executor = new Executor(new DefaultEnvironment());
-            executor.environment.Set("user", Lisp_Object.FromBase(user));
+            executor.environment.Set("user", new Lisp_Object(user));
-            if (Plugin.Instance is not null) {
-                executor.eval(Plugin.Instance.Configuration.InitialProgram);
-            } else {
-                throw new ApplicationException("Plugin Instance is not yet initialized");
-            }
             foreach (var i in items) {
-                executor.environment.Set("item", Lisp_Object.FromBase(i));
+                executor.environment.Set("item", new Lisp_Object(i));
                 var r = executor.eval(expression);
                 _logger.LogTrace("Item {0} evaluated to {1}", i, r.ToString());
-                if ((r is not Lisp_Boolean r_bool) || (r_bool.Value())) {
+                if ((r is not Lisp_Boolean r_bool) || (r_bool.value)) {
                     _logger.LogDebug("Added '{0}' to Smart Playlist {1}", i, smartPlaylist.Name);
-                    results.Add(i);
+                    results.Add(i.Id);
                 }
             }
-            executor = new Executor(new DefaultEnvironment());
+            return results;
-            executor.environment.Set("user", Lisp_Object.FromBase(user));
-            executor.environment.Set("items", Lisp_Object.FromBase(results));
-            results = new List<BaseItem>();
-            var sort_result = executor.eval(smartPlaylist.SortProgram);
-            if (sort_result is Cons sorted_items) {
-                foreach (var i in sorted_items.ToList()) {
-                    if (i is Lisp_Object iObject && iObject.Value() is BaseItem iBaseItem) {
-                        results.Add(iBaseItem);
-                        continue;
-                    }
-                    throw new ApplicationException($"Returned sorted list does contain unexpected items, got {i}");
-                }
-            } else if (sort_result == Lisp_Boolean.FALSE) {
-            } else {
-                throw new ApplicationException($"Did not return a list of items, returned {sort_result}");
-            }
-            return results.Select(x => x.Id);
         }
 
         private IEnumerable<BaseItem> GetAllUserMedia(User user) {
@@ -168,7 +157,6 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
                     _store.DeleteSmartPlaylist(dto); // delete in case the file was not the canonical one.
                     await _store.SaveSmartPlaylistAsync(dto);
                 }
-                var i = 0;
                 foreach (SmartPlaylistLinkDto playlistLink in dto.Playlists) {
                     User? user = _userManager.GetUserById(playlistLink.UserId);
                     if (user == null) {
@@ -178,8 +166,6 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
                     var playlist = _playlistManager.GetPlaylists(playlistLink.UserId).Where(x => x.Id == playlistLink.PlaylistId).First();
                     await ClearPlaylist(playlist);
                     await _playlistManager.AddItemToPlaylistAsync(playlist.Id, insertItems, playlistLink.UserId);
-                    i += 1;
-                    progress.Report(100 * ((double)i)/dto.Playlists.Count());
                 }
             }
         }
@@ -190,7 +176,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
                 throw new ArgumentException("");
             }
             var existingItems = playlist_new.GetManageableItems().ToList();
-            await _playlistManager.RemoveItemFromPlaylistAsync(playlist.Id.ToString(), existingItems.Select(x => x.Item1.ItemId?.ToString("N", CultureInfo.InvariantCulture)));
+            await _playlistManager.RemoveItemFromPlaylistAsync(playlist.Id.ToString(), existingItems.Select(x => x.Item1.Id));
         }
     }
 }

Jellyfin.Plugin.SmartPlaylist/SmartPlaylistDto.cs

@@ -41,22 +41,19 @@ namespace Jellyfin.Plugin.SmartPlaylist {
 
     [Serializable]
     public class SmartPlaylistDto : ISerializable {
-        private static string DEFAULT_PROGRAM = "(begin (invoke item \"IsFavoriteOrLiked\" (list user)))";
+        private static string DEFAULT_PROGRAM = "(begin (invoke item 'IsFavoriteOrLiked' (user)))";
-        private static string DEFAULT_SORT_PROGRAM = "(begin items)";
         public SmartPlaylistId Id { get; set; }
         public SmartPlaylistLinkDto[] Playlists { get; set; }
         public string Name { get; set; }
         public string Program { get; set; }
-        public string SortProgram { get; set; }
         public string? Filename { get; set; }
         public bool Enabled { get; set; }
 
         public SmartPlaylistDto() {
-            Id = "";
+            Id = Guid.NewGuid();
             Playlists = [];
             Name = Id.ToString();
             Program = DEFAULT_PROGRAM;
-            SortProgram = DEFAULT_SORT_PROGRAM;
             Filename = null;
             Enabled = true;
         }
@@ -65,7 +62,7 @@ namespace Jellyfin.Plugin.SmartPlaylist {
             if (info.GetValue("Id", typeof(SmartPlaylistId)) is SmartPlaylistId _Id) {
                 Id = _Id;
             } else {
-                Id = "";
+                Id = Guid.NewGuid();
             }
             if (info.GetValue("Playlists", typeof(SmartPlaylistLinkDto[])) is SmartPlaylistLinkDto[] _Playlists) {
                 Playlists = _Playlists;
@@ -82,11 +79,6 @@ namespace Jellyfin.Plugin.SmartPlaylist {
             } else {
                 Program = DEFAULT_PROGRAM;
             }
-            if (info.GetValue("SortProgram", typeof(string)) is string _SortProgram) {
-                SortProgram = _SortProgram;
-            } else {
-                SortProgram = DEFAULT_SORT_PROGRAM;
-            }
             if (info.GetValue("Filename", typeof(string)) is string _Filename) {
                 Filename = _Filename;
             } else {

Jellyfin.Plugin.SmartPlaylist/SmartPlaylistFileSystem.cs

@@ -16,21 +16,13 @@ namespace Jellyfin.Plugin.SmartPlaylist {
         }
         public string StoragePath { get; }
         public string GetSmartPlaylistFilePath(SmartPlaylistId smartPlaylistId) {
-            return Path.Combine(StoragePath, $"{smartPlaylistId}.yaml");
+            return Path.Combine(StoragePath, $"{smartPlaylistId}.json");
         }
         public string FindSmartPlaylistFilePath(SmartPlaylistId smartPlaylistId) {
-            return Directory.GetFiles(StoragePath, $"{smartPlaylistId}.yaml", SearchOption.AllDirectories).Concat(
+            return Directory.GetFiles(StoragePath, $"{smartPlaylistId}.json", SearchOption.AllDirectories).First();
-                Directory.GetFiles(StoragePath, $"{smartPlaylistId}.yml", SearchOption.AllDirectories)
-            ).Concat(
-                Directory.GetFiles(StoragePath, $"{smartPlaylistId}.json", SearchOption.AllDirectories)
-            ).First();
         }
         public string[] FindAllSmartPlaylistFilePaths() {
-            return Directory.GetFiles(StoragePath, "*.yaml", SearchOption.AllDirectories).Concat(
+            return Directory.GetFiles(StoragePath, "*.json", SearchOption.AllDirectories);
-                Directory.GetFiles(StoragePath, "*.yml", SearchOption.AllDirectories)
-            ).Concat(
-                Directory.GetFiles(StoragePath, "*.json", SearchOption.AllDirectories)
-            ).ToArray();
         }
     }
 }

Jellyfin.Plugin.SmartPlaylist/Store.cs

@@ -1,4 +1,4 @@
-using YamlDotNet.Serialization;
+using System.Text.Json;
 
 namespace Jellyfin.Plugin.SmartPlaylist {
     public interface IStore {
@@ -14,24 +14,12 @@ namespace Jellyfin.Plugin.SmartPlaylist {
             _fileSystem = fileSystem;
         }
         private async Task<SmartPlaylistDto> LoadPlaylistAsync(string filename) {
-            var r = await File.ReadAllTextAsync(filename);
+            await using var r = File.OpenRead(filename);
-            if (r.Equals("")) {
+            var dto = (await JsonSerializer.DeserializeAsync<SmartPlaylistDto>(r).ConfigureAwait(false));
-                r = "{}";
+            if (dto == null) {
-            }
-            var dto = new DeserializerBuilder().Build().Deserialize<SmartPlaylistDto>(r);
-            if (dto == null)
-            {
                 throw new ApplicationException("");
             }
-            if (dto.Id != Path.GetFileNameWithoutExtension(filename)) {
+            dto.Filename = filename;
-                dto.Id = Path.GetFileNameWithoutExtension(filename);
-            }
-            if (dto.Name != Path.GetFileNameWithoutExtension(filename)) {
-                dto.Name = Path.GetFileNameWithoutExtension(filename);
-            }
-            if (dto.Filename != filename) {
-                dto.Filename = filename;
-            }
             return dto;
         }
         public async Task<SmartPlaylistDto> GetSmartPlaylistAsync(SmartPlaylistId smartPlaylistId) {
@@ -45,8 +33,8 @@ namespace Jellyfin.Plugin.SmartPlaylist {
         }
         public async Task SaveSmartPlaylistAsync(SmartPlaylistDto smartPlaylist) {
             string filename = _fileSystem.GetSmartPlaylistFilePath(smartPlaylist.Id);
-            var text = new SerializerBuilder().Build().Serialize(smartPlaylist);
+            await using var w = File.Create(filename);
-            await File.WriteAllTextAsync(filename, text);
+            await JsonSerializer.SerializeAsync(w, smartPlaylist).ConfigureAwait(false);
         }
         private void DeleteSmartPlaylistById(SmartPlaylistId smartPlaylistId) {
             try {

Jellyfin.Plugin.SmartPlaylist/Types.cs

@@ -2,4 +2,4 @@ global using System;
 
 global using UserId = System.Guid;
 global using PlaylistId = System.Guid;
-global using SmartPlaylistId = string;
+global using SmartPlaylistId = System.Guid;

Jellyfin.Plugin.SmartPlaylist/build.yaml

@@ -1,7 +1,7 @@
 name: Smart Playlist
 guid: dd2326e3-4d3e-4bfc-80e6-28502c1131df
-version: 0.2.2.0
+version: 0.1.1.0
-targetAbi: 10.10.2.0
+targetAbi: 10.10.0.0
 framework: net8.0
 owner: redxef
 overview: Smart playlists with Lisp filter engine.
@@ -12,32 +12,5 @@ description: |
 category: "General"
 artifacts:
   - jellyfin-smart-playlist.dll
-  - YamlDotNet.dll
 changelog: |
-  ## v0.2.2.0
-  - Update Jellyfin to v 10.10.2
-
-  ## v0.2.1.0
-  - Make default program configuration a textarea in the settings page
-  - Add convinience definitions: `is-type`, `name-contains`
-  - Update YamlDotNet to v 16.2.0
-
-  **Fixes**:
-  - The default program was malformed, a closing bracket was at the wrong position
-  - The `haskeys` function could only be called on Objects
-
-  ## v0.2.0.0
-  - Switch to yaml loading, old json files are still accepted
-  - Rework lisp interpreter to be more conventional
-  - Use arbitrary strings as ids for playlists
-  - Add configuration page with some default definitions for
-    the filter expressions.
-
-  **Breaking Changes:**
-  - The lisp interpreter will now only detect strings in double quotes (`"`).
-  - The interpreter will also not allow specifying lists without quoting them.
-    `(1 2 3)` ... used to work but will no longer, replace by either specifying
-    the list as `(list 1 2 3)` or `(quote (1 2 3))`.
-
-  ## v0.1.1.0
   - Initial Alpha release.

Jellyfin.Plugin.SmartPlaylist/configPage.html

@@ -2,17 +2,35 @@
 <html lang="en">
 <head>
     <meta charset="utf-8">
-    <title>SmartPlaylist</title>
+    <title>Template</title>
 </head>
 <body>
-    <div id="SmartPlaylistConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox">
+    <div id="TemplateConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox">
         <div data-role="content">
             <div class="content-primary">
-                <form id="SmartPlaylistConfigForm">
+                <form id="TemplateConfigForm">
+                    <div class="selectContainer">
+                        <label class="selectLabel" for="Options">Several Options</label>
+                        <select is="emby-select" id="Options" name="Options" class="emby-select-withcolor emby-select">
+                            <option id="optOneOption" value="OneOption">One Option</option>
+                            <option id="optAnotherOption" value="AnotherOption">Another Option</option>
+                        </select>
+                    </div>
                     <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="InitialProgram">Initial Program</label>
+                        <label class="inputLabel inputLabelUnfocused" for="AnInteger">An Integer</label>
-                        <div class="fieldDescription">A program which can set up the environment</div>
+                        <input id="AnInteger" name="AnInteger" type="number" is="emby-input" min="0" />
-                        <textarea id="InitialProgram" class="emby-input smartplaylist-monospace" name="InitialProgram" rows="16" cols="120"></textarea>
+                        <div class="fieldDescription">A Description</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="TrueFalseSetting" name="TrueFalseCheckBox" type="checkbox" is="emby-checkbox" />
+                            <span>A Checkbox</span>
+                        </label>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="AString">A String</label>
+                        <input id="AString" name="AString" type="text" is="emby-input" />
+                        <div class="fieldDescription">Another Description</div>
                     </div>
                     <div>
                         <button is="emby-button" type="submit" class="raised button-submit block emby-button">
@@ -22,31 +40,32 @@
                 </form>
             </div>
         </div>
-        <style>
-            .smartplaylist-monospace {
-                font-family: monospace;
-            }
-        </style>
         <script type="text/javascript">
-            var SmartPlaylistConfig = {
+            var TemplateConfig = {
                 pluginUniqueId: 'dd2326e3-4d3e-4bfc-80e6-28502c1131df'
             };
 
-            document.querySelector('#SmartPlaylistConfigPage')
+            document.querySelector('#TemplateConfigPage')
                 .addEventListener('pageshow', function() {
                     Dashboard.showLoadingMsg();
-                    ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
+                    ApiClient.getPluginConfiguration(TemplateConfig.pluginUniqueId).then(function (config) {
-                        document.querySelector('#InitialProgram').value = config.InitialProgram;
+                        document.querySelector('#Options').value = config.Options;
+                        document.querySelector('#AnInteger').value = config.AnInteger;
+                        document.querySelector('#TrueFalseSetting').checked = config.TrueFalseSetting;
+                        document.querySelector('#AString').value = config.AString;
                         Dashboard.hideLoadingMsg();
                     });
                 });
 
-            document.querySelector('#SmartPlaylistConfigForm')
+            document.querySelector('#TemplateConfigForm')
                 .addEventListener('submit', function(e) {
                 Dashboard.showLoadingMsg();
-                ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
+                ApiClient.getPluginConfiguration(TemplateConfig.pluginUniqueId).then(function (config) {
-                    config.InitialProgram = document.querySelector('#InitialProgram').value;
+                    config.Options = document.querySelector('#Options').value;
-                    ApiClient.updatePluginConfiguration(SmartPlaylistConfig.pluginUniqueId, config).then(function (result) {
+                    config.AnInteger = document.querySelector('#AnInteger').value;
+                    config.TrueFalseSetting = document.querySelector('#TrueFalseSetting').checked;
+                    config.AString = document.querySelector('#AString').value;
+                    ApiClient.updatePluginConfiguration(TemplateConfig.pluginUniqueId, config).then(function (result) {
                         Dashboard.processPluginConfigurationUpdateResult(result);
                     });
                 });

Jellyfin.Plugin.SmartPlaylist/jellyfin-smart-playlist.csproj

@@ -2,21 +2,15 @@
 
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
-    <RootNamespace>Jellyfin.Plugin.SmartPlaylist</RootNamespace>
+    <RootNamespace>jellyfin_smart_playlist</RootNamespace>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <Version>0.2.2.0</Version>
+    <Version>0.1.1.0</Version>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Jellyfin.Controller" Version="10.10.3" />
+    <PackageReference Include="Jellyfin.Controller" Version="10.10.0" />
-    <PackageReference Include="Jellyfin.Model" Version="10.10.3" />
+    <PackageReference Include="Jellyfin.Model" Version="10.10.0" />
-    <PackageReference Include="YamlDotNet" Version="16.2.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Remove="configPage.html"/>
-    <EmbeddedResource Include="configPage.html"/>
   </ItemGroup>
 
 </Project>

README.md

@@ -2,57 +2,41 @@
 
 Smart playlists with Lisp filter engine.
 
-This readme contains instructions for the most recent changes in
-the development branch (`main`). To view the file appropriate
-for your version select the tag corresponding to your version.
-The latest version is [v0.2.2.0](https://gitea.redxef.at/redxef/jellyfin-smart-playlist/src/tag/v0.2.2.0).
-
 ## How to use
 
 After [installing](#installation) the plugin and restarting Jellyfin
-create a empty file in `config/data/smartplaylists` like this, maybe
+create a file in `config/data/smartplaylists` like this:
-you want to generate a playlist of your favourite rock songs:
 
 ```
-$ touch config/data/smartplaylists/Rock.yaml
+$ echo '{}' > config/data/smartplaylists/a.json
 ```
 
 Afterwards run the Task `(re)generate Smart Playlists`, this will rename
-the `yaml` file and populate it with some default values. You can now
+the `json` file and populate it with some default values. You can now
-adjust the file to your liking. [Go here](examples.md) to see more
+adjust the file to your liking. [Go here](examples/index.md) to see more
 examples.
 
-```yaml
+Example file
-Id: Rock
+```json
-Playlists:
+{
-- PlaylistId: 24f12e1e-3278-d6d6-0ca4-066e93296c95
+  "Id": "a1d02dee-f1da-4472-bee3-f568c15c8360",
-  UserId: 6eec632a-ff0d-4d09-aad0-bf9e90b14bc6
+  "Playlists": [
-Name: Rock
+    {
-Program: (begin (invoke item "IsFavoriteOrLiked" (user)))
+      "PlaylistId": "24f12e1e-3278-d6d6-0ca4-066e93296c95",
-SortProgram: (begin items)
+      "UserId": "6eec632a-ff0d-4d09-aad0-bf9e90b14bc6"
-Filename: /config/data/smartplaylists/Rock.yaml
+    }
-Enabled: true
+  ],
+  "Name": "a1d02dee-f1da-4472-bee3-f568c15c8360",
+  "Program": "(begin (invoke item 'IsFavoriteOrLiked' (user)))",
+  "Filename": "/config/data/smartplaylists/a1d02dee-f1da-4472-bee3-f568c15c8360.json",
+  "Enabled": true
+}
 ```
 
-This is the default configuration and will always match all your
-favorite songs (and songs which are in favourited albums).
-
-To change the filter you can append a `|` (pipe) to the Program
-line and write multiline filters like this:
-
-```yaml
-Porgram: |
-  (begin
-    (invoke item "IsFavoriteOrLiked" (list user)))
-```
-
-This is equivalent to the above example (not counting the other
-fields obviously).
-
-
 ### Id
 
 Arbitrary Id assigned to this playlist, can usually be left alone.
+The filename is derived from this.
 
 ### Playlists
 
@@ -79,60 +63,17 @@ The user associated with this playlist.
 
 The name of the generated playlists, this is just a default value.
 If the user changes the name of their playlist the plugin will
-still work and remember the correct playlist.
+work as usual
 
 ### Program
 
 A lisp program to decide on a per item basis if it should be included in
-the playlist, return `nil` to not include items, return any other value
+the playlist, return `nil` to not include items, return `t` to include
-to include them. Global variables `user` and `item` are predefined
+them.
-and contain a [User](https://github.com/jellyfin/jellyfin/blob/master/Jellyfin.Data/Entities/User.cs) and
-[BaseItem](https://github.com/jellyfin/jellyfin/blob/master/MediaBrowser.Controller/Entities/BaseItem.cs)
-respectively.
-
-**!!! The filter expression will include all items matching, if you do
-not specify the kind of item to include/exclude all of them will be
-added. Should you allow a playlist to be included all of it's items
-will be added to the generated playlist !!!**
-
-It's best to be explicit and always specify the item kinds you want to
-include: `(and (or (is-type "MusicAlbum") (is-type "Audio")) . rest of filter)`.
-
-The configuration page defines some useful functions to make it easier
-to create filters. The above filter for liked items could be simplified
-to: `(is-favourite)`.
-
-### SortProgram
-
-This works exactly like [Program](#program), but the input is the
-user and a list of items (`items`) matched by [Program](#program).
-The default is `(begin items)`, which doesn't sort at all. To sort
-the items by name you could use the following program:
-
-```lisp
-(qsort
-  (lambda
-    (a b)
-    (string>
-      (car (getitems a "Name"))
-      (car (getitems b "Name"))))
-  items)
-```
-
-#### Available definitions
-
-- **lower**: lowercases a string (`(eq (lower "SomeString") "somestring")`)
-- **is-genre**: check if the item is of this genre, partial matches
-  allowed, the example filter would match the genre "Nu-Metal" (`(is-genre "metal" (genre-list))`)
-- **is-genre-exact**: the same as `is-genre`, but does not match paritally
-- **is-favorite**: matches a favorite item (`(is-favorite)`)
-- **is-type**: matches the type of item look at
-  [BaseItemKind.cs](https://github.com/jellyfin/jellyfin/blob/master/Jellyfin.Data/Enums/BaseItemKind.cs)
-  for a list of items. The plugin has enabled support for `Audio, MusicAlbum, Playlist` (`(is-type "Audio")`)
 
 ### Filename
 
-The path to this file, only used internally and updated by the program.
+The path to this file.
 
 ### Enabled
 
@@ -148,17 +89,3 @@ to Jellyfin:
 Go to `Dashboard>Catalog>(Gear)>(Plus)` and paste the provided link into
 the field labeled `Repository URL`, give the plugin a descriptive name
 too.
-
-## Releasing a new version
-
-1. Write the changelog: `git log --oneline $prev_version..`
-2. Update the following files to include up-to-date version numbers
-   and changelogs, if applicable:
-   - `README.md`
-   - `Jellyfin.Plugin.SmartPlaylist/build.yaml`
-   - `Jellyfin.Plugin.SmartPlaylist/jellyfin-smart-playlist.csproj`
-   Don't forget to also bump the ABI version of Jellyfin.
-3. Push the changes
-4. Create a new release with the changelog, mark as pre-release if
-   applicable.
-5. Done! The build pipeline will do the rest.

Tests/Tests.cs

@@ -1,5 +1,7 @@
-using Lisp_Boolean = Jellyfin.Plugin.SmartPlaylist.Lisp.Boolean;
+using Xunit;
-using Lisp_Object = Jellyfin.Plugin.SmartPlaylist.Lisp.Object;
+using Lisp_Environment = Jellyfin.Plugin.SmartPlaylist.Lisp.Environment;
+using Lisp_Boolean = Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler.Boolean;
+using Lisp_Object = Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler.Object;
 using Jellyfin.Plugin.SmartPlaylist.Lisp;
 using Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler;
 
@@ -14,42 +16,45 @@ namespace Tests
         }
         public int i { get => _i; }
         public bool b { get => _b; }
-        public int I() {
-            return _i;
-        }
     }
 
     public class Test {
         [Fact]
         public static void TestTokenizer() {
             StringTokenStream sts = StringTokenStream.generate("(\"some literal string\" def ghj +100 -+300 1 >= ++ !=)");
-            Assert.Equal("(", sts.Get().value);
+            Assert.Equal(sts.Get().value, "(");
-            Assert.Equal("\"", sts.Get().value);
+            Assert.Equal(sts.Get().value, "\"");
-            Assert.Equal("some", sts.Get().value);
+            Assert.Equal(sts.Get().value, "some");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal("literal", sts.Get().value);
+            Assert.Equal(sts.Get().value, "literal");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal("string", sts.Get().value);
+            Assert.Equal(sts.Get().value, "string");
-            Assert.Equal("\"", sts.Get().value);
+            Assert.Equal(sts.Get().value, "\"");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal("def", sts.Get().value);
+            Assert.Equal(sts.Get().value, "def");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal("ghj", sts.Get().value);
+            Assert.Equal(sts.Get().value, "ghj");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal("+100", sts.Get().value);
+            Assert.Equal(sts.Get().value, "+");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, "100");
-            Assert.Equal("-+300", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, "-");
-            Assert.Equal("1", sts.Get().value);
+            Assert.Equal(sts.Get().value, "+");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, "300");
-            Assert.Equal(">=", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, "1");
-            Assert.Equal("++", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
-            Assert.Equal(" ", sts.Get().value);
+            Assert.Equal(sts.Get().value, ">");
-            Assert.Equal("!=", sts.Get().value);
+            Assert.Equal(sts.Get().value, "=");
-            Assert.Equal(")", sts.Get().value);
+            Assert.Equal(sts.Get().value, " ");
+            Assert.Equal(sts.Get().value, "+");
+            Assert.Equal(sts.Get().value, "+");
+            Assert.Equal(sts.Get().value, " ");
+            Assert.Equal(sts.Get().value, "!");
+            Assert.Equal(sts.Get().value, "=");
+            Assert.Equal(sts.Get().value, ")");
             sts.Commit();
-            Assert.Equal(0, sts.Available());
+            Assert.Equal(sts.Available(), 0);
         }
 
         [Fact]
@@ -63,171 +68,116 @@ namespace Tests
             sts = StringTokenStream.generate(program);
             p = new Parser(sts);
             Assert.Equal(program, string.Format("{0}", p.parse()));
+
+            //program = "(* 2.4 2)";
+            //sts = StringTokenStream.generate(program);
+            //p = new Parser(sts);
+            //Assert.Equal(program, p.parse().ToString());
         }
 
         [Fact]
         public static void TestFunctions() {
-            Executor e = new Executor();
+            IList<Tuple<string, Expression>> cases = new List<Tuple<string, Expression>>();
-            Assert.Equal("(1 2 3)", e.eval("(quote (1 2 3))").ToString());
+            Expression e = new Executor().eval("(+ 10 20)");
-            Assert.Equal("abc", e.eval("(quote abc)").ToString());
+            Assert.Equal(((Integer) e).value, 30);
 
-            Assert.Equal("t", e.eval("(atom 1)").ToString());
+            e = new Executor().eval("(> 1 2)");
-            Assert.Equal("nil", e.eval("(atom (quote (1 2 3)))").ToString());
+            Assert.Equal(((Lisp_Boolean) e).value, false);
 
-            Assert.Equal("t", e.eval("(eq 2 2)").ToString());
+            e = new Executor().eval("(if (> 1 2) 3 4)");
-            Assert.Equal("nil", e.eval("(eq 2 3)").ToString());
+            Assert.Equal(((Integer) e).value, 4);
 
-            Assert.Equal("1", e.eval("(car (quote (1 2 3)))").ToString());
+            e = new Executor().eval("(begin (define x 1) x)");
-            Assert.Equal("(2 3)", e.eval("(cdr (quote (1 2 3)))").ToString());
+            Assert.Equal(((Integer) e).value, 1);
 
-            Assert.Equal("(1 . 2)", e.eval("(cons 1 2)").ToString());
+            e = new Executor().eval("(apply + (1 2))");
-            Assert.Equal("(1 2)", e.eval("(cons 1 (cons 2 nil))").ToString());
+            Assert.Equal(((Integer) e).value, 3);
-            Assert.Equal("(1)", e.eval("(cons 1 nil)").ToString());
-            Assert.Equal("(1)", e.eval("(cons 1 ())").ToString());
 
-            Assert.Equal("\"Case 2\"", e.eval("""
+            e = new Executor().eval("(car (10 20 30))");
-                (cond
+            Assert.Equal(((Integer) e).value, 10);
-                    ((eq 1 2) "Case 1")
-                    ((eq 2 2) "Case 2"))
-            """).ToString());
-            Assert.Equal("\"Case 1\"", e.eval("""
-                (cond
-                    ((eq 2 2) "Case 1")
-                    ((eq 2 2) "Case 2"))
-            """).ToString());
-            Assert.Equal("nil", e.eval("""
-                (cond
-                    ((eq 1 2) "Case 1")
-                    ((eq 3 2) "Case 2"))
-            """).ToString());
 
-            Assert.Equal("t", e.eval("((lambda (a) (eq a a)) 2)").ToString());
+            e = new Executor().eval("(cdr (10 20 30))");
+            Assert.Equal(string.Format("{0}", e), "(20 30)");
 
-            Assert.Equal("t", e.eval("(begin (car (quote (nil 1))) t)").ToString());
+            e = new Executor().eval("(cons 1 3)");
-            Assert.Equal("(1)", e.eval("(begin t (cdr (quote (nil 1))))").ToString());
+            Assert.Equal(string.Format("{0}", e), "(1 3)");
 
-            Assert.Equal("t", e.eval("""
+            e = new Executor().eval("(cons 1 (2 3))");
-                (begin
+            Assert.Equal(string.Format("{0}", e), "(1 2 3)");
-                    (define abc 10)
-                    (eq abc abc))
-            """).ToString());
 
-            Assert.Equal("1", e.eval("""
+            e = new Executor().eval("(length (cons 1 (2 3)))");
-                (begin
+            Assert.Equal(string.Format("{0}", e), "3");
-                    (define if (lambda (condition a b) (
-                        cond (condition a) (t b))))
-                    (if (> 2 1) (car (quote (1 2 3))) (cdr (quote (2 3 4)))))
-            """).ToString());
-            Assert.Equal("(3 4)", e.eval("""
-                (begin
-                    (define if (lambda (condition a b) (
-                        cond (condition a) (t b))))
-                    (if (> 0 1) (car (quote (1 2 3))) (cdr (quote (2 3 4)))))
-            """).ToString());
 
-        }
+            e = new Executor().eval("(>= 2 2)");
+            Assert.Equal(string.Format("{0}", e), "t");
 
-        [Fact]
+            e = new Executor().eval("(> 2 2))");
-        public static void TestFunctionsAdvanced() {
+            Assert.Equal(string.Format("{0}", e), "nil");
-            Executor e = new Executor();
-            Assert.Equal("2", e.eval("""
-                ((lambda (b) b) (car (quote (2 3))))
-            """).ToString());
 
-            Assert.Equal("(3 4 5)", e.eval("""
+            e = new Executor().eval("(and 2 3 4)");
-                ((lambda (x y . z) z) 1 2 3 4 5)
+            Assert.Equal("4", e.ToString());
-            """).ToString());
 
-            Assert.Equal("3", e.eval("""
+            e = new Executor().eval("(and 2 nil 4)");
-                (begin
+            Assert.Equal("nil", e.ToString());
-                    (define if (lambda (condition a b) (cond (condition a) (t b))))
-                    (if (< 1 2) 3 2))
-            """).ToString());
 
-            Assert.Equal("2", e.eval("""
+            e = new Executor().eval("(or 2 nil 4)");
-                (begin
+            Assert.Equal("2", e.ToString());
-                    (define if (lambda (condition a b) (cond (condition a) (t b))))
+
-                    (if (> 1 2) 3 2))
+            e = new Executor().eval("(or nil 4)");
-            """).ToString());
+            Assert.Equal("4", e.ToString());
-            Assert.Equal("1", e.eval("""
+
-                (begin
+            e = new Executor().eval("(= (1 2) (1 2))");
-                    (define if (lambda* (condition a b) (
+            Assert.Equal(e.ToString(), "t");
-                        cond ((eval condition) (eval a)) (t (eval b)))))
+
-                    (if (> 2 1) (car (quote (1 2 3))) (cdr (quote (2 3 4)))))
+            e = new Executor().eval("(= (1 2 3) (1 2))");
-            """).ToString());
+            Assert.Equal(e.ToString(), "nil");
-            Assert.Equal("(3 4)", e.eval("""
-                (begin
-                    (define if (lambda* (condition a b) (
-                        cond ((eval condition) (eval a)) (t (eval b)))))
-                    (if (> 0 1) (car (quote (1 2 3))) (cdr (quote (2 3 4)))))
-            """).ToString());
-            Assert.Equal("120", e.eval("""
-                (begin
-                    (define f (lambda (n) (cond ((<= n 1) 1) (t (* n (f (- n 1)))))))
-                    (f 5))
-            """).ToString());
-            Assert.Equal("120", e.eval("""
-                (begin
-                    (define if (lambda* (condition a b) (
-                        cond ((eval condition) (eval a)) (t (eval b)))))
-                    (define f (lambda (n) (if (<= n 1) 1 (* n (f (- n 1))))))
-                    (f 5))
-            """).ToString());
-            Assert.Equal("(1 2 3 4 5)", e.eval("""
-                (begin
-                    (define if (lambda* (condition a b) (
-                        cond ((eval condition) (eval a)) (t (eval b)))))
-                    ((lambda (. args) args) 1 2 3 4 5))
-            """).ToString());
-            Assert.Equal("t", e.eval("""
-                (begin
-                    (define null (lambda* (x) (
-                        cond ((eval x) nil) (t t))))
-                    (null nil))
-            """).ToString());
-            Assert.Equal("nil", e.eval("""
-                (begin
-                    (define null (lambda* (x) (cond ((eval x) nil) (t t))))
-                    (null (quote (1 2))))
-            """).ToString());
         }
         [Fact]
         public static void ObjectTest() {
             Executor e = new Executor();
             Expression r;
-            e.environment.Set("o", Lisp_Object.FromBase(new O(5, false)));
+            e.environment.Set("o", new Lisp_Object(new O(5, false)));
-            r = e.eval("""(haskeys o "i" "b")""");
+            r = e.eval("(haskeys o 'i' 'b')");
-            Assert.True(((Lisp_Boolean)r).Value());
+            Assert.Equal(((Lisp_Boolean)r).value, true);
-            r = e.eval("""(getitems o "i" "b")""");
+            r = e.eval("(getitems o 'i' 'b')");
-            Assert.Equal("(5 nil)", string.Format("{0}", r));
+            Assert.Equal(string.Format("{0}", r), "(5 nil)");
-            r = e.eval("""(invoke o "I" nil)""");
+        }
-            Assert.Equal("5", string.Format("{0}", r));
+
+        [Fact]
+        public static void ScalarTest() {
+            Executor e = new Executor();
+            Expression r;
+
+            r = e.eval("(* 2  2)");
+            Assert.Equal("4", r.ToString());
+        }
+
+        [Fact]
+        public static void ProcedureTest() {
+            Executor e = new Executor();
+            Expression r;
+            r = e.eval("((lambda (a) (* a a)) 2)");
+            Assert.Equal(string.Format("{0}", r), "4");
+
+            r = e.eval("(begin (define mull (lambda (a) (* a a))) (mull 3))");
+            Assert.Equal(string.Format("{0}", r), "9");
+
+            r = e.eval("(begin (define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1)))))) (fact 10))");
+            Assert.Equal(string.Format("{0}", r), "3628800");
+
+            r = e.eval("(begin (define find (lambda (item list) (if (= list ()) nil (if (= item (car list)) (car list) (find item (cdr list)))))) (find 3 (1 2 3 4)))");
+            Assert.Equal(string.Format("{0}", r), "3");
+
+            e = new Executor();
+            r = e.eval("(begin (define find (lambda (item list) (if (= list ()) nil (if (= item (car list)) (car list) (find item (cdr list)))))) (find 0 (1 2 3 4)))");
+            Assert.Equal(string.Format("{0}", r), "nil");
         }
 
         [Fact]
         public static void DefaultEnvironmentTest() {
             Executor e = new Executor(new DefaultEnvironment());
-            Assert.Equal("1", e.eval("(if nil 0 1)").ToString());
+            Assert.Equal("nil", e.eval("(find 0 (1 2 3 4))").ToString());
-            Assert.Equal("0", e.eval("(if t 0 1)").ToString());
+            Assert.Equal("3", e.eval("(find 3 (1 2 3 4))").ToString());
-            Assert.Equal("5", e.eval("(if t (if t 5 nil) nil)").ToString());
-            Assert.Equal("nil", e.eval("(if t (if nil 5 nil) nil)").ToString());
-            Assert.Equal("(1 2 3)", e.eval("(list 1 2 3)").ToString());
-            Assert.Equal("3", e.eval("(find 3 (list 1 2 3 4))").ToString());
-            Assert.Equal("nil", e.eval("(find 0 (list 1 2 3 4))").ToString());
-            Assert.Equal("(2 4 6)", e.eval("(map (lambda (x) (* x 2)) (quote (1 2 3)))").ToString());
-            Assert.Equal("nil", e.eval("(and 1 2 3 nil)").ToString());
-            Assert.Equal("t", e.eval("(and t t t t)").ToString());
-            Assert.Equal("t", e.eval("(or nil nil t nil)").ToString());
-            Assert.Equal("nil", e.eval("(or nil nil nil nil)").ToString());
-            Assert.Equal("t", e.eval("(any (lambda (x) (= x 2)) (list 1 2 3 4 5 6))").ToString());
-            Assert.Equal("nil", e.eval("(any (lambda (x) (= x 2)) (list 1 3 4 5 6))").ToString());
-            Assert.Equal("nil", e.eval("(any (lambda (x) (= x 2)) nil)").ToString());
-            Assert.Equal("t", e.eval("(all (lambda (x) (= 1 (% x 2))) (list 1 3 5))").ToString());
-            Assert.Equal("nil", e.eval("(all (lambda (x) (= 1 (% x 2))) (list 1 3 4 5))").ToString());
-            Assert.Equal("nil", e.eval("(all (lambda (x) (= x 2)) nil)").ToString());
-            Assert.Equal("10", e.eval("(fold (lambda (a b) (+ a b)) 0 (list 1 2 3 4))").ToString());
-            Assert.Equal("(2 3 4 5 6 7)", e.eval("(append (list 2 3 4) (list 5 6 7))").ToString());
-            Assert.Equal("(1 2 3 4 5 6 7)", e.eval("(qsort (lambda (a b) (> a b)) (list 5 4 7 3 2 6 1))").ToString());
         }
     }
 }

examples.md

@@ -1,27 +0,0 @@
-# Examples
-
-- `Favourite Pop`: A playlist
-  containing all favourite items of the genre pop.
-  ```
-  Id: Favourite Pop
-  Name: Favourite Pop
-  Program: |
-    (and (is-type "Audio") (is-favorite) (is-genre "pop" (genre-list)))
-  ```
-- `Electro Swing`: A playlist containing all items
-  which have a genre that contains "electro" and a
-  genre that contains "swing". It will only include
-  albums and single tracks.
-  ```
-  Id: Electro Swing
-  Name: Electro Swing
-  Program: |
-    (let
-      (g (genre-list))
-      (and
-        (or
-          (is-type "Audio")
-          (is-type "MusicAlbum"))
-        (is-genre "electro" g)
-        (is-genre "swing" g)))
-  ```

examples/a1d02dee-f1da-4472-bee3-f568c15c8360.json

@@ -0,0 +1,5 @@
+{
+  "Id": "a1d02dee-f1da-4472-bee3-f568c15c8360",
+  "Name": "Favourite Pop",
+  "Program": "(and (invoke item 'IsFavoriteOrLiked' (user)) (find 'Pop' (car (getitems item 'Genres'))))"
+}

examples/index.md

@@ -0,0 +1,4 @@
+# Examples
+
+* [Favourite Pop](a1d02dee-f1da-4472-bee3-f568c15c8360.json): A Playlist
+  containing all favourite items of the genre pop.