Composable Data Validations. Func Delegates Everywhere

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ComposableCore
{
    public class fState<T, S> where S : ICloneable
    {
        //De essentie van deze klasse is dat
        //hij geen enkele State member variabele kent en resultaten Kloont 
        //Zo krijgt een externe caller via getState() GEEN reference pointer naar een eigen state uit deze klasse
        //zodat hij alsnog, buiten de stateSetter, de interne state van deze klasse kan wijzigen.
        private Action<S, T> _statesetter;
        private fType<S, S> _invoke;
        private Func<Unit, S> _getstate;
        private Func<Unit, S> _resetstate;
        private Action<S> _resetsetter;
        public fState(Action<S, T> stateSetter, S stateHolder, Action<S> resetSetter)
        {
            //Encapsulate stateholder variable in Action! (private voor de action)
            Func<S, Action<S, T>> init = (x =>
            {
                x = stateHolder;
                return stateSetter;
            });
            //Encapsulate stateholder variable in Action! (private voor de action)
            Func<S, Action<S>> initreset = (x =>
            {
                x = stateHolder;
                return resetSetter;
            });

            _statesetter = init.Invoke(stateHolder);
            _invoke = fType.toFtype<S, S>(y => stateHolder);
            _getstate = (x => stateHolder);
            _resetsetter = initreset.Invoke(stateHolder);
            _resetstate = (x => stateHolder);
        }
        public void resetState()
        {
            if (_resetstate != null && _resetsetter != null)
            {
                _resetsetter(_resetstate.Invoke(new Unit()));
            }
        }
        public void setState(T value)
        {
            fType<S, S> theninvoke = fType.toFtype<S, S>(y =>
            {
                _statesetter(y, value);
                return y;
            });
            _invoke = _invoke.Then(theninvoke);
        }
        public S getState()
        {
            S ret = _invoke.Invoke(_getstate.Invoke(new Unit()));
            _invoke = fType.toFtype<S, S>(y => ret);
            return (S)ret.Clone();
        }
    }
}