private static Zen <T2> Simplify(Zen <T1> expr, string fieldName, bool unroll)
{
// get(with(o, name, f), name) == f
// get(with(o, name', f), name) == get(o, name)
if (expr is ZenWithFieldExpr <T1, T2> e1)
{
return((e1.FieldName == fieldName) ?
e1.FieldValue :
Create(e1.Expr, fieldName)); // recurse
}
// get(if e1 then e2 else e3, name) = if e1 then get(e2, name) else get(e3, name)
if (unroll && expr is ZenIfExpr <T1> e2)
{
var trueBranch = Create(e2.TrueExpr, fieldName);
var falseBranch = Create(e2.FalseExpr, fieldName);
return(ZenIfExpr <T2> .Create(e2.GuardExpr, trueBranch.Unroll(), falseBranch.Unroll()));
}
// get(createobject(p1, ..., pn), namei) == pi
if (expr is ZenCreateObjectExpr <T1> coe)
{
return((Zen <T2>)coe.Fields[fieldName]);
}
return(new ZenGetFieldExpr <T1, T2>(expr, fieldName));
}
private static Zen <FiniteString> At(Zen <IList <ushort> > s, Zen <ushort> i, int current)
{
return(s.Case(
empty: FiniteString.Empty(),
cons: (hd, tl) =>
If(i == (ushort)current, FiniteString.Singleton(hd), At(tl, i, current + 1))));
}
/// <summary>
/// Gets the first index of a substring in a
/// string starting at an offset.
/// </summary>
/// <param name="s">The string.</param>
/// <param name="sub">The substring.</param>
/// <param name="offset">The offset.</param>
/// <returns>An index.</returns>
public static Zen <Option <ushort> > IndexOf(this Zen <FiniteString> s, Zen <FiniteString> sub, Zen <ushort> offset)
{
var trimmed = s.GetCharacters().Drop(offset);
var idx = IndexOf(trimmed, sub.GetCharacters(), 0);
return(If(idx.HasValue(), Some(idx.Value() + offset), idx));
}
/// <summary>
/// Create a new ZenStringLengthExpr.
/// </summary>
/// <param name="expr">The string expr.</param>
/// <returns>The new Zen expr.</returns>
public static Zen <BigInteger> Create(Zen <string> expr)
{
CommonUtilities.ValidateNotNull(expr);
hashConsTable.GetOrAdd(expr.Id, () => Simplify(expr), out var value);
return(value);
}
private static Zen <TResult> Simplify(Zen <IList <T> > e, Zen <TResult> emptyCase, Func <Zen <T>, Zen <IList <T> >, Zen <TResult> > consCase)
{
if (e is ZenListEmptyExpr <T> l1)
{
return(emptyCase);
}
if (e is ZenListAddFrontExpr <T> l2)
{
return(consCase(l2.Element, l2.Expr));
}
if (Settings.SimplifyRecursive)
{
if (e is ZenIfExpr <IList <T> > l3)
{
var tbranch = ZenListCaseExpr <T, TResult> .Create(l3.TrueExpr, emptyCase, consCase);
var fbranch = ZenListCaseExpr <T, TResult> .Create(l3.FalseExpr, emptyCase, consCase);
return(ZenIfExpr <TResult> .Create(l3.GuardExpr, tbranch, fbranch));
}
}
return(new ZenListCaseExpr <T, TResult>(e, emptyCase, consCase));
}
/// <summary>
/// Create a new ZenBitwiseNot expr.
/// </summary>
/// <param name="expr"></param>
/// <returns></returns>
public static Zen <T> Create(Zen <T> expr)
{
CommonUtilities.ValidateNotNull(expr);
CommonUtilities.ValidateIsIntegerType(typeof(T));
hashConsTable.GetOrAdd(expr.Id, () => Simplify(expr), out var value);
return(value);
}
private static Zen <bool> StartsWith(Zen <IList <ushort> > s, Zen <IList <ushort> > pre)
{
return(pre.Case(
empty: true,
cons: (hd1, tl1) => s.Case(
empty: false,
cons: (hd2, tl2) => AndIf(hd1 == hd2, StartsWith(tl2, tl1)))));
}
/// <summary>
/// Find all inputs that solve the constraint.
/// </summary>
/// <param name="input">Default input that captures structural constraints.</param>
/// <param name="listSize">The maximum number of elements to consider in an input list.</param>
/// <param name="checkSmallerLists">Whether to check smaller list sizes as well.</param>
/// <param name="backend">The backend.</param>
/// <returns>An input if one exists satisfying the constraints.</returns>
public IEnumerable <T> FindAll(
Zen <T> input = null,
int listSize = 5,
bool checkSmallerLists = true,
Backend backend = Backend.Z3)
{
return(this.FindAll((i, o) => o, input, listSize, checkSmallerLists, backend));
}
/// <summary>
/// Initializes a new instance of the <see cref="ZenListCaseExpr{TList, TResult}"/> class.
/// </summary>
/// <param name="listExpr">The list.</param>
/// <param name="empty">The empty case.</param>
/// <param name="cons">The cons case.</param>
private ZenListCaseExpr(
Zen <IList <T> > listExpr,
Zen <TResult> empty,
Func <Zen <T>, Zen <IList <T> >, Zen <TResult> > cons)
{
this.ListExpr = listExpr;
this.EmptyCase = empty;
this.ConsCase = cons;
}
/// <summary>
/// Get a constant string value.
/// </summary>
/// <typeparam name="T">The type.</typeparam>
/// <param name="value">The Zen string value.</param>
/// <returns>A string.</returns>
public static string GetConstantString <T>(Zen <T> value)
{
if (value is ZenConstantStringExpr xs)
{
return(xs.UnescapedValue);
}
return(null);
}
public static Zen <ushort> Simplify(Zen <string> e1)
{
var x = ReflectionUtilities.GetConstantString(e1);
if (x != null)
{
return(x.Length);
}
return(new ZenStringLengthExpr(e1));
}
public static Zen <TResult> Create(
Zen <IList <T> > listExpr,
Zen <TResult> empty,
Func <Zen <T>, Zen <IList <T> >, Zen <TResult> > cons)
{
CommonUtilities.ValidateNotNull(listExpr);
CommonUtilities.ValidateNotNull(empty);
CommonUtilities.ValidateNotNull(cons);
return(Simplify(listExpr, empty, cons));
}
private static Zen <bool> Simplify(Zen <bool> e)
{
if (e is ZenConstantBoolExpr x)
{
return(x.Value ? ZenConstantBoolExpr.False : ZenConstantBoolExpr.True);
}
if (e is ZenNotExpr y)
{
return(y.Expr);
}
return(new ZenNotExpr(e));
}
public static Zen <bool> Create(Zen <bool> expr)
{
CommonUtilities.ValidateNotNull(expr);
if (hashConsTable.TryGetValue(expr, out var value))
{
return(value);
}
var ret = Simplify(expr);
hashConsTable[expr] = ret;
return(ret);
}
private static Zen <bool> Simplify(Zen <bool> e)
{
if (e is ZenConstantExpr <bool> x)
{
return(x.Value ? ZenConstantExpr <bool> .Create(false) : ZenConstantExpr <bool> .Create(true));
}
if (e is ZenNotExpr y)
{
return(y.Expr);
}
return(new ZenNotExpr(e));
}
public static Zen <T> Create(Zen <T> expr)
{
CommonUtilities.ValidateNotNull(expr);
CommonUtilities.ValidateIsIntegerType(typeof(T));
if (hashConsTable.TryGetValue(expr, out var value))
{
return(value);
}
var ret = Simplify(expr);
hashConsTable[expr] = ret;
return(ret);
}
public static Zen <TTo> CreateMulti(Zen <TFrom> expr, ImmutableList <Func <object, object> > converters, bool unroll = false)
{
CommonUtilities.ValidateNotNull(expr);
var key = (expr, ConvertersHashCode(converters), unroll);
if (hashConsTable.TryGetValue(key, out var value))
{
return(value);
}
var ret = Simplify(expr, converters, unroll);
hashConsTable[key] = ret;
return(ret);
}
private static Zen <T> Simplify(Zen <T> e)
{
var x = ReflectionUtilities.GetConstantIntegerValue(e);
if (x.HasValue)
{
return(ReflectionUtilities.CreateConstantValue <T>(~x.Value));
}
if (e is ZenBitwiseNotExpr <T> y)
{
return(y.Expr);
}
return(new ZenBitwiseNotExpr <T>(e));
}
private static Zen <TTo> Simplify(Zen <TFrom> e, ImmutableList <Func <object, object> > converters, bool unroll)
{
// adapt(t1, t2, adapt(t2, t1, e)) == e
if (e is ZenAdapterExpr <TFrom, TTo> inner1)
{
return(inner1.Expr);
}
if (unroll && e is ZenIfExpr <TFrom> inner2)
{
var trueBranch = CreateMulti(inner2.TrueExpr, converters);
var falseBranch = CreateMulti(inner2.FalseExpr, converters);
return(ZenIfExpr <TTo> .Create(inner2.GuardExpr, trueBranch.Unroll(), falseBranch.Unroll()));
}
return(new ZenAdapterExpr <TTo, TFrom>(e, converters));
}
public static Zen <T2> Create(Zen <T1> expr, string fieldName, bool unroll = false)
{
CommonUtilities.ValidateNotNull(expr);
CommonUtilities.ValidateNotNull(fieldName);
ReflectionUtilities.ValidateFieldOrProperty(typeof(T1), typeof(T2), fieldName);
var key = (expr, fieldName, unroll);
if (hashConsTable.TryGetValue(key, out var value))
{
return(value);
}
var ret = Simplify(expr, fieldName, unroll);
hashConsTable[key] = ret;
return(ret);
}
private static Zen <TTo> Simplify(Zen <TFrom> e, ImmutableList <Func <object, object> > converters)
{
// adapt(t1, t2, adapt(t2, t1, e)) == e
if (e is ZenAdapterExpr <TFrom, TTo> inner1)
{
return(inner1.Expr);
}
// adapt(t1, t2, adapt(t2, t3, e)) == adapt(t1, t3, e)
/* var type = e.GetType();
* if (type.GetGenericTypeDefinition() == typeof(ZenAdapterExpr<,>))
* {
* if (type.GetGenericArguments()[0] == typeof(T2))
* {
* var type1 = typeof(T1);
* var type3 = type.GetGenericArguments()[1];
* var astType = typeof(ZenAdapterExpr<,>).MakeGenericType(type1, type3);
* var paramType1 = typeof(Zen<>).MakeGenericType(type3);
* var paramType2 = typeof(ImmutableList<>).MakeGenericType(typeof(Func<object, object>));
* var method = astType.GetMethod("CreateMulti");
* var param1 = type.GetProperty("Expr").GetValue(e);
* var converters = (ImmutableList<Func<object, object>>)type.GetProperty("Converters").GetValue(e);
* var param2 = converters.AddRange(expression.Converters);
* return (Zen<T1>)method.Invoke(null, new object[] { param1, param2 });
* }
* } */
if (Settings.SimplifyRecursive)
{
if (e is ZenIfExpr <TFrom> inner2)
{
var trueBranch = ZenAdapterExpr <TTo, TFrom> .CreateMulti(inner2.TrueExpr, converters);
var falseBranch = ZenAdapterExpr <TTo, TFrom> .CreateMulti(inner2.FalseExpr, converters);
return(ZenIfExpr <TTo> .Create(inner2.GuardExpr, trueBranch, falseBranch));
}
}
return(new ZenAdapterExpr <TTo, TFrom>(e, converters));
}
private static Zen <TResult> Simplify(Zen <IList <T> > e, Zen <TResult> emptyCase, Func <Zen <T>, Zen <IList <T> >, Zen <TResult> > consCase, bool unroll)
{
if (e is ZenListEmptyExpr <T> l1)
{
return(emptyCase);
}
if (e is ZenListAddFrontExpr <T> l2)
{
return(consCase(l2.Element, l2.Expr));
}
if (unroll && e is ZenIfExpr <IList <T> > l3)
{
var tbranch = Create(l3.TrueExpr, emptyCase, consCase);
var fbranch = Create(l3.FalseExpr, emptyCase, consCase);
return(ZenIfExpr <TResult> .Create(l3.GuardExpr, tbranch.Unroll(), fbranch.Unroll()));
}
return(new ZenListCaseExpr <T, TResult>(e, emptyCase, consCase));
}
/// <summary>
/// Get an integer value as a long.
/// </summary>
/// <typeparam name="T">The integer gype.</typeparam>
/// <param name="value">The Zen integer value.</param>
/// <returns>A long.</returns>
public static long?GetConstantIntegerValue <T>(Zen <T> value)
{
if (value is ZenConstantByteExpr xb)
{
return(xb.Value);
}
if (value is ZenConstantShortExpr xs)
{
return(xs.Value);
}
if (value is ZenConstantUshortExpr xus)
{
return(xus.Value);
}
if (value is ZenConstantIntExpr xi)
{
return(xi.Value);
}
if (value is ZenConstantUintExpr xui)
{
return(xui.Value);
}
if (value is ZenConstantLongExpr xl)
{
return(xl.Value);
}
if (value is ZenConstantUlongExpr xul)
{
return((long?)xul.Value);
}
return(null);
}
/// <summary>
/// Replaces all occurrences of a given character with another.
/// </summary>
/// <param name="s">The string.</param>
/// <param name="src">The source value.</param>
/// <param name="dst">The destination value.</param>
/// <returns>A new string.</returns>
public static Zen <FiniteString> ReplaceAll(this Zen <FiniteString> s, Zen <ushort> src, Zen <ushort> dst)
{
return(FiniteString.Create(s.GetCharacters().Select(c => If(c == src, dst, c))));
}
/// <summary>
/// Initializes a new instance of the <see cref="ZenStringLengthExpr"/> class.
/// </summary>
/// <param name="expr">The string expression.</param>
private ZenStringLengthExpr(Zen <string> expr)
{
this.Expr = expr;
}
/// <summary>
/// Initializes a new instance of the <see cref="ZenBitwiseNotExpr{T}"/> class.
/// </summary>
/// <param name="expr">The expression.</param>
private ZenBitwiseNotExpr(Zen <T> expr)
{
this.Expr = expr;
}
/// <summary>
/// Removes all occurrences of a given character.
/// </summary>
/// <param name="s">The string.</param>
/// <param name="value">The value to remove.</param>
/// <returns>A new string.</returns>
public static Zen <FiniteString> RemoveAll(this Zen <FiniteString> s, Zen <ushort> value)
{
return(Transform(s, l => l.Where(c => c != value)));
}
/// <summary>
/// Transform a string by modifying its characters.
/// </summary>
/// <param name="s">The string.</param>
/// <param name="f">The transformation function.</param>
/// <returns>A new string.</returns>
public static Zen <FiniteString> Transform(this Zen <FiniteString> s, Func <Zen <IList <ushort> >, Zen <IList <ushort> > > f)
{
return(FiniteString.Create(f(s.GetCharacters())));
}
/// <summary>
/// Creates an empty string.
/// </summary>
/// <returns>The empty string.</returns>
public static Zen <FiniteString> Singleton(Zen <ushort> b)
{
return(Create(Language.Singleton(b)));
}
/// <summary>
/// Creates an FiniteString.
/// </summary>
/// <returns>The empty string.</returns>
public static Zen <FiniteString> Create(Zen <IList <ushort> > values)
{
return(Create <FiniteString>(("Characters", values)));
}
