SOMDocs.cs 29.39 KiB
using JsonSubTypes;
using Newtonsoft.Json;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Linq;
using System;
using UnityEngine;
using MoreLinq;
namespace REST_JSON_API
{
public class ApproximationComparer : EqualityComparer<object>
{
public static readonly ApproximationComparer Instance = new();
public override bool Equals(object x, object y)
{
if (x.Equals(y))
return true;
if (x.GetType() != y.GetType())
return false;
if (x is float fx)
return Mathf.Approximately(fx, (float)y);
if (x is Vector3 vx)
return Math3d.IsApproximatelyEqual(vx, (Vector3)y);
return false;
}
public override int GetHashCode(object obj)
{
if (obj is float)
return typeof(float).GetHashCode();
if (obj is Vector3)
return typeof(Vector3).GetHashCode();
return obj.GetHashCode();
}
}
[JsonConverter(typeof(JsonSubtypes), "kind")]
[JsonSubtypes.KnownSubType(typeof(RAW), "RAW")]
[JsonSubtypes.KnownSubType(typeof(OMS), "OMS")]
[JsonSubtypes.KnownSubType(typeof(OMA), "OMA")]
[JsonSubtypes.KnownSubType(typeof(OMV), "VAR")]
[JsonSubtypes.KnownSubType(typeof(OML_Member), "OML")]
[JsonSubtypes.KnownSubType(typeof(FUN), "FUN")]
[JsonSubtypes.KnownSubType(typeof(FUNTYPE), "FUNTYPE")]
//[JsonSubtypes.KnownSubType(typeof(OMC<T>), "OMC<" + typeof(T).Name + ">")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<bool>), "OMLIT<Boolean>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<byte>), "OMLIT<Byte>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<short>), "OMLIT<Int16>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<int>), "OMLIT<Int32>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<long>), "OMLIT<Int64>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<float>), "OMLIT<Single>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<float>), "OMLIT<Double>")] // we dont use double
[JsonSubtypes.KnownSubType(typeof(OMLIT<string>), "OMLIT<String>")]
[JsonSubtypes.KnownSubType(typeof(OMLIT<Vector3>), "OMLIT<Vector3>")]
[JsonSubtypes.FallBackSubType(typeof(FallbackWrapper))]
//[JsonSubtypes.KnownSubType(typeof(FallbackWrapper), "SFunction")]
//[JsonSubtypes.KnownSubTypeWithProperty(typeof(FallbackWrapper), "SFunction")]
abstract public partial class SOMDoc
{
public string kind;
protected SOMDoc() { kind = this.GetType().Name; }
protected internal abstract SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params);
public SOMDoc SOMDocType() => SOMDocType(new SOMDoc[0], new FUN.Param[0]);
public static SOMDoc SOMDocType(Type type)
{
SOMDoc[] args = type.IsGenericType
? type.GetGenericArguments().Select(t => SOMDocType(t)).ToArray()
: type.HasElementType ? new[] { SOMDocType(type.GetElementType()) }
: null;
if (type == typeof(Vector3) // Isomoprhismus
|| TupleExtensions.IsTupleType(type, out _)) // Dictionary does not like Generics
type = typeof(Tuple);
if (type.HasElementType) // pretend its a List
type = typeof(List<>);
if (type.IsGenericType) // Dictionary does not like Assembled Generics
type = type.GetGenericTypeDefinition();
if (FuncExtensions.IsFuncType(type, out _))
return new FUNTYPE(args[..^1], args[^1]);
if (MMTConstants.TYPE_TO_OMS.TryGetValue(type, out string uri))
return args != null
? new OMA(new OMS(uri), args)
: new OMS(uri);
if (type.IsAnonymousType())
return new OMA(
new OMS(MMTConstants.MakeTypeType),
type.GetFields()
.Select(mem => new OML_Member(mem.Name, SOMDocType(mem.FieldType), null))
.ToArray());
throw new NotImplementedException($"For Type {type}");
}
// change to SOMDoc[] args?
protected internal abstract Type ToType(Type[] args, (string name, Type type)[] bound_params);
public Type ToType()
=> ToType(new Type[0], new (string name, Type type)[0]);
public static bool Equivalent(SOMDoc sd1, SOMDoc sd2)
=> sd1 != null && sd2 != null
&& sd1.Equivalent(sd2);
public abstract bool Equivalent(SOMDoc sd2);
public LambdaExpression GetLambdaExpression()
=> GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], new ParameterExpression[0]);
protected internal abstract LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params);
public abstract override string ToString();
public abstract SOMDoc MapURIs(Dictionary<string, string> old_to_new);
public abstract string[] GetDependentFactIds();
#region MakeMMT_OMS_URItoSOMDoc
public static Vector3 MakeVector3(OMA tuple)
{
if (tuple.arguments is not OMLIT<float>[] xyz
|| xyz.Length < 3)
throw new FormatException("Argument " + nameof(tuple) + "." + nameof(OMA.arguments)
+ " expected to be: " + nameof(OMLIT<float>) + "[3]");
return new Vector3((float)xyz[0].value, (float)xyz[1].value, (float)xyz[2].value);
}
public static OMA MakeVector3(Vector3 vec)
=> MakeTupel(new[] {
new OMLIT<float>(vec.x),
new OMLIT<float>(vec.y),
new OMLIT<float>(vec.z),
});
public static OMA MakeTupel(SOMDoc[] args)
=> new(
new OMS(MMTConstants.Tuple),
args
);
public static OMA MakeShallowList(SOMDoc[] args)
=> new(
new OMS(MMTConstants.ListApplicant),
args
);
public static OMA MakeDeepList(SOMDoc[] args, SOMDoc SOMDoc_type)
{
SOMDoc[] end_of_list = new SOMDoc[] {
new OMA(
new OMS(MMTConstants.ListEnd),
new[] {
SOMDoc_type,
}
),
args.Length == 0
? null
: args[^1]
};
if (args.Length == 0)
end_of_list = end_of_list[..^0];
SOMDoc defines = new OMA(
new OMS(MMTConstants.ListLiteral),
end_of_list
);
for (int i = args.Length - 2; i >= 0; i--)
{
defines = new OMA(
new OMS(MMTConstants.ListLiteral),
new[] {
defines,
args[i],
});
}
SOMDoc type = new OMA(
new OMS(MMTConstants.ListType),
new[] { SOMDoc_type }
);
return new OMA(type, new[] { defines });
}
#endregion MakeMMT_OMS_URItoSOMDoc
}
public abstract class SOMDocCRTP<T> : SOMDoc where T : SOMDocCRTP<T>
{
protected SOMDocCRTP() : base() { }
public override bool Equivalent(SOMDoc sd2)
=> this.GetType() == sd2.GetType() && (this as T).EquivalentWrapped(sd2 as T);
protected abstract bool EquivalentWrapped(T sd2);
public override SOMDoc MapURIs(Dictionary<string, string> old_to_new)
=> MapURIsWrapped(old_to_new);
protected abstract T MapURIsWrapped(Dictionary<string, string> old_to_new);
}
public class FUNTYPE : SOMDocCRTP<FUNTYPE>
{
public new string kind = "FUNTYPE";
public SOMDoc[] @params;
public SOMDoc ret;
[JsonConstructor]
public FUNTYPE(SOMDoc[] @params, SOMDoc ret)
{
this.@params = @params;
this.ret = ret;
}
public override string ToString()
=> "["
+ string.Join(", ", @params.Select(p => p.ToString()))
+ "] => {"
+ ret.ToString()
+ "}";
protected override bool EquivalentWrapped(FUNTYPE sd2)
=> @params.Length == sd2.@params.Length
&& @params.Zip(sd2.@params, (a, b) => a.Equivalent(b))
.All(b => b)
&& ret.Equivalent(sd2.ret);
protected override FUNTYPE MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(@params.Select(p => p.MapURIs(old_to_new)).ToArray()
, ret.MapURIs(old_to_new));
public override string[] GetDependentFactIds()
=> new string[0];
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
{
throw new NotImplementedException();
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
throw new NotImplementedException();
}
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> FuncExtensions.CreateFuncType(Enumerable.Append(@params.Select(p => p.ToType()), ret.ToType()).ToArray());
}
public class FUN : SOMDocCRTP<FUN>
{
public new string kind = "FUN";
public Param[] @params;
public SOMDoc body;
[JsonConstructor]
public FUN(Param[] @params, SOMDoc body)
{
this.@params = @params;
this.body = body;
}
public class Param
{
public string name;
[JsonProperty("tp")]
public SOMDoc type;
[JsonConstructor]
public Param(string name, SOMDoc tp)
{
this.name = name;
this.type = tp;
}
public override string ToString()
=> name + "(" + type.ToString() + ")";
}
public override string ToString()
=> "["
+ string.Join(", ", @params.Select(p => p.ToString()))
+ "] => {"
+ body.ToString()
+ "}";
protected override bool EquivalentWrapped(FUN sd2)
=> @params.Length == sd2.@params.Length
&& @params.Zip(sd2.@params, (a, b) => a.name.Equals(b.name)
&& a.type.Equivalent(b.type))
.All(b => b)
&& body.Equivalent(sd2.body);
protected override FUN MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(@params.Select(p => new Param(p.name, p.type.MapURIs(old_to_new))).ToArray()
, body.MapURIs(old_to_new));
public override string[] GetDependentFactIds()
=> body.GetDependentFactIds();
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
{
ParameterExpression[] local_param =
@params.Select(p => Expression.Parameter(p.type.ToType(), p.name)).ToArray();
LambdaExpression body_lambda =
body.GetLambdaExpression(
lambda_applicant,
lambda_arguments,
bound_params.ShallowCloneAppend(local_param)
);
return
Expression.Lambda(
Expression.Lambda(
body_lambda.Body,
local_param
),
bound_params
);
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, Param[] bound_params)
{
Param[] bind_me = bound_params.ShallowCloneAppend(@params);
return new FUNTYPE(
@params.Select(p => p.type).ToArray(),
body.SOMDocType(new SOMDoc[0], bind_me)
); }
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
{
(string name, Type)[] bind_me = bound_params
.AppendRange(@params.Select(p => (p.name, p.type.ToType())))
.ToArray();
return SOMDocType().ToType(new Type[0], bind_me);
}
}
public class OMV : SOMDocCRTP<OMV>
{
public new string kind = "VAR";
public string name;
[JsonConstructor]
public OMV(string name) : base()
{
this.name = name;
}
protected override bool EquivalentWrapped(OMV sd2)
=> this.name == sd2.name;
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
FUN.Param p = bound_params.FirstOrDefault(param => param.name.Equals(name))
?? throw new FormatException($"Unable to find {nameof(FUN.Param)} for {nameof(OMV)} with name: {name}");
return p.type;
}
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
{
(string name, Type type) p = bound_params.FirstOrDefault(param => param.name.Equals(name));
if (p == default)
throw new FormatException($"Unable to find {nameof(FUN.Param)} for {nameof(OMV)} with name: {name}");
return p.type;
}
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
{
ParameterExpression v = bound_params.FirstOrDefault(param => param.Name.Equals(name));
if (v == null)
{
Debug.LogErrorFormat("Unable to find {0} for {1} with name: {2}", nameof(FUN.Param), nameof(OMV), name);
return Expression.Lambda(Expression.Empty(), null);
}
else
return Expression.Lambda(v, new[] { v });
}
public override string ToString()
=> "Variable_" + "(" + name + ")";
protected override OMV MapURIsWrapped(Dictionary<string, string> old_to_new)
=> (OMV)this.MemberwiseClone();
public override string[] GetDependentFactIds()
=> new string[0];
}
public class OMA : SOMDocCRTP<OMA>
{
public new string kind = "OMA";
public SOMDoc applicant;
public SOMDoc[] arguments;
[JsonConstructor]
public OMA(SOMDoc applicant, SOMDoc[] arguments) : base()
{
this.applicant = applicant;
this.arguments = arguments;
}
protected override bool EquivalentWrapped(OMA sd2)
=> Equivalent(this.applicant, sd2.applicant)
&& this.arguments
.Zip(sd2.arguments, (arg1, arg2) => Equivalent(arg1, arg2))
.All(b => b);
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_arguments_paps, LambdaExpression[] lambda_arguments_grands, ParameterExpression[] bound_params)
{
if (applicant is OMS OMSMake)
if (OMSMake.uri == MMTConstants.MakeType
|| OMSMake.uri == MMTConstants.MakeTypeType)
{
KeyValuePair<string, LambdaExpression>[] members = arguments
.Select(arg => (OML_Member)arg)
.Select(rec => new KeyValuePair<string, LambdaExpression>(
rec.name,
(rec.defines ?? rec.of_type)
.GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], bound_params)))
.ToArray();
return SOMDocToLambdaExpression.MakeType(members, bound_params);
}
return applicant.GetLambdaExpression(
arguments.Select(arg => arg.GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], bound_params)).ToArray(),
lambda_arguments_paps,
bound_params
);
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
if (applicant is OMS OMSMake
&& OMSMake.uri == MMTConstants.GetField)
{
return (arguments[0] as OMA).arguments
.Select(arg => (OML_Member)arg) //RECTYPE?
.First(rec => rec.name == ((OML_Member)arguments[1]).name)
.defines.SOMDocType(new SOMDoc[0], bound_params);
}
return applicant.SOMDocType(
arguments.Select(a => a.SOMDocType(new SOMDoc[0], bound_params)).ToArray(),
bound_params
);
}
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
{
if (applicant is OMS OMSMake)
if (OMSMake.uri == MMTConstants.MakeType
|| OMSMake.uri == MMTConstants.MakeTypeType)
{
KeyValuePair<string, Type>[] members = arguments
.Select(arg => (OML_Member)arg)
.Select(rec => new KeyValuePair<string, Type>(
rec.name,
rec.of_type.ToType(new Type[0], bound_params)))
.ToArray();
return TupleFactory.Create(members).TupleType;
}
else
if (OMSMake.uri == MMTConstants.GetField)
{
return args[0].GetMember(((OML_Member)arguments[1]).name).First().ReflectedType;
}
return applicant.ToType(
arguments.Select(arg => arg.ToType(new Type[0], bound_params)).ToArray(),
bound_params
);
}
public override string ToString()
=> applicant.ToString() + "(" + string.Join(", ", arguments.Select(a => a.ToString())) + ")";
protected override OMA MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new OMA(
applicant.MapURIs(old_to_new),
arguments.Select(arg => arg.MapURIs(old_to_new)).ToArray()
);
public override string[] GetDependentFactIds()
=> applicant.GetDependentFactIds()
.AppendRange(arguments.SelectMany(arg => arg.GetDependentFactIds()))
.ToArray();
}
public class OMS : SOMDocCRTP<OMS>
{
public new string kind = "OMS";
public string uri;
[JsonConstructor]
public OMS(string uri) : base()
{
this.uri = uri;
}
protected override bool EquivalentWrapped(OMS sd2)
{
bool
b1 = FactRecorder.AllFacts.TryGetValue(uri, out Fact f1),
b2 = FactRecorder.AllFacts.TryGetValue(sd2.uri, out Fact f2);
return (b1 == b2 && uri == sd2.uri)
|| (b1 && b2 && f1.Equivalent(f2));
}
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_arguments_paps, LambdaExpression[] lambda_arguments_grands, ParameterExpression[] bound_params)
=> SOMDocToLambdaExpression.MakeLambdaExpression(uri, lambda_arguments_paps, lambda_arguments_grands, bound_params);
public override string ToString()
=> uri;
protected override OMS MapURIsWrapped(Dictionary<string, string> old_to_new)
{
if (!old_to_new.TryGetValue(uri, out string new_uri))
new_uri = uri;
return new OMS(new_uri);
}
public override string[] GetDependentFactIds()
=> FactRecorder.AllFacts.ContainsKey(uri)
? new string[] { uri } : new string[0];
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
{
if (FactRecorder.AllFacts.TryGetValue(uri, out Fact found))
return found.GetType();
if (MMTConstants.HeterogenApplication_TO_TypeOF.TryGetValue(uri, out string s_type))
{
Type type = MMTConstants.OMS_TO_TYPE[s_type];
if (type.Equals(typeof(Tuple)))
{ // authors note: Not a fan, but has to be done somewhwere...
if (args.Length == 3
&& args.All(t => t == typeof(float)))
return typeof(Vector3);
type = TupleExtensions.GetGenericTupleType(args.Length);
}
else
if (type.Equals(typeof(Func<>)))
return FuncExtensions.CreateFuncType(args);
return type
.MakeGenericType(args);
}
if (MMTConstants.HomogenApplication_TO_TypeOF.TryGetValue(uri, out s_type))
return MMTConstants.OMS_TO_TYPE[s_type]
.MakeGenericType(args[0]);
if (MMTConstants.URI_TO_TypeOF.TryGetValue(uri, out s_type))
return MMTConstants.OMS_TO_TYPE[s_type];
if (MMTConstants.OMS_TO_TYPE.TryGetValue(uri, out Type t_type))
return t_type;
throw new NotImplementedException();
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
{
string _uri = uri;
bool use_uri;
if (use_uri = MMTConstants.OMS_TO_TYPE.TryGetValue(_uri, out Type tmp_type))
_uri = MMTConstants.TYPE_TO_OMS[tmp_type];
if (FactRecorder.AllFacts.TryGetValue(_uri, out Fact found))
return new OMS(MMTConstants.TYPE_TO_OMS[found.GetType()]);
if (MMTConstants.HeterogenApplication_TO_TypeOF.TryGetValue(_uri, out string type))
return new OMA(
new OMS(type),
args
);
if (MMTConstants.HomogenApplication_TO_TypeOF.TryGetValue(_uri, out type))
return new OMA(
new OMS(type),
new[] { args[0] }
);
if (MMTConstants.URI_TO_TypeOF.TryGetValue(_uri, out type))
return new OMS(type);
if (use_uri)
return SOMDocType(tmp_type);
//return new OMS(_uri);
throw new NotImplementedException(uri); }
}
public class RAW : SOMDocCRTP<RAW>
{
public new string kind = "RAW";
public string xml;
[JsonConstructor]
public RAW(string xml) : base()
{
this.xml = xml;
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> throw new NotSupportedException();
protected override RAW MapURIsWrapped(Dictionary<string, string> old_to_new)
{
string copy = xml;
foreach (KeyValuePair<string, string> KeyVal in old_to_new)
copy = copy.Replace(KeyVal.Key, KeyVal.Value);
return new RAW(copy);
}
public override string[] GetDependentFactIds()
=> new string[0];
public override string ToString()
=> xml;
protected override bool EquivalentWrapped(RAW sd2)
=> throw new NotImplementedException(); //xml == sd2.xml; // only exact
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> throw new NotSupportedException();
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> throw new NotSupportedException();
}
// tp == null && df == null: member access
// tp != null : member/type declaration
// df != null : member value
public class OML_Member : SOMDocCRTP<OML_Member>
{
public new string kind = "OML";
[JsonProperty("name")]
public string name;
[JsonProperty("tp")]
public SOMDoc of_type;
[JsonProperty("df")]
public SOMDoc defines;
[JsonConstructor]
public OML_Member(string name, SOMDoc of_type, SOMDoc defines)
{
this.name = name;
this.of_type = of_type;
this.defines = defines;
}
public override string[] GetDependentFactIds()
=> defines?.GetDependentFactIds() ?? new string[0];
public override string ToString()
{
string tp = of_type == null ? string.Empty : $": {of_type}";
string df = defines == null ? string.Empty : $" = {{{defines}}}";
return $".{name}" + tp + df;
}
protected override bool EquivalentWrapped(OML_Member sd2)
=> name == sd2.name
&& ((of_type == null && sd2.of_type == null) || of_type.Equivalent(sd2.of_type))
&& ((defines == null && sd2.defines == null) || defines.Equivalent(sd2.defines));
protected override OML_Member MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(name, of_type?.MapURIs(old_to_new), defines?.MapURIs(old_to_new));
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> defines == null && of_type == null
? Expression.Lambda(Expression.Constant(name, typeof(string))) // PropertyInfo? => would need info about sister element in OMA.arguments
: throw new NotSupportedException(); //=> new KeyValuePair<string, Expression>(name, value.GetLambdaExpression(lambda_applicant, lambda_arguments, bound_params))
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> new OML_Member(
name,
of_type
?? defines?.SOMDocType(args, bound_params)
?? throw new NotSupportedException(), // would need info about sister element in OMA.arguments
null
);
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> defines?.ToType(args, bound_params)
//?? of_type?.ToType(args, bound_params) //is Member Declaration not Member Type
?? throw new NotSupportedException(); // would need info about sister element in OMA.arguments
}
public class OMLIT<T> : SOMDocCRTP<OMLIT<T>>
{
public new string kind = "OMLIT<" + typeof(T).Name + ">";
public string type;
public T value;
[JsonConstructor]
public OMLIT(T value, string type = null) : base()
{
this.value = value;
this.type = type ?? MMTConstants.TYPE_TO_OMS[value.GetType()];
}
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> SOMDocType(typeof(T));
protected override bool EquivalentWrapped(OMLIT<T> sd2)
=> ApproximationComparer.Instance.Equals(value, sd2);
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> Expression.Lambda(Expression.Constant(value, typeof(T)), null);
public override string ToString()
=> value.ToString();
protected override OMLIT<T> MapURIsWrapped(Dictionary<string, string> old_to_new)
=> (OMLIT<T>)this.MemberwiseClone();
public override string[] GetDependentFactIds()
=> new string[0];
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> typeof(T); }
// temporary fix if Serialzation is broken
public class FallbackWrapper : SOMDocCRTP<FallbackWrapper>
{
public new string kind = "SFunction";
public SOMDoc SFunction;
[JsonConstructor]
public FallbackWrapper(SOMDoc SFunction)
{
this.SFunction = SFunction;
}
public override string ToString()
=> SFunction.ToString();
protected override bool EquivalentWrapped(FallbackWrapper sd2)
=> SFunction.Equivalent(sd2);
protected override FallbackWrapper MapURIsWrapped(Dictionary<string, string> old_to_new)
=> new(SFunction.MapURIs(old_to_new));
protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
=> SFunction.GetLambdaExpression(lambda_applicant, lambda_arguments, bound_params);
protected internal override SOMDoc SOMDocType(SOMDoc[] args, FUN.Param[] bound_params)
=> SFunction.SOMDocType(args, bound_params);
protected internal override Type ToType(Type[] args, (string name, Type type)[] bound_params)
=> SFunction.ToType(args, bound_params);
public override string[] GetDependentFactIds()
=> SFunction.GetDependentFactIds();
}
}