-- import Adam.StructInstWithHoles
-- import Mathlib


-- example : Module ℚ ℝ := by
--   refine { ?..! }
--   exact fun a r => a * r
--   intro b
--   sorry
--   sorry
--   sorry
--   sorry
--   sorry
--   sorry
--   sorry

-- structure Foo where
--   x : Nat := 0
--   y : Nat

-- structure Bar extends Foo where
--   z : Nat := x

-- example := by refine { ?.. : Foo }; case y => exact 0
-- example := by refine { ?.. : Bar }; case y => exact 0
-- example := by refine { ?..a : Bar }; case a.y => exact 0
-- example := by refine { ?..! : Bar }; case x | y | z => exact 0;
-- example := by refine { ?..!a : Bar }; case a.x | a.y | a.z => exact 0;
-- -- example := by refine' { ... : Bar }; exact 0
-- example := by refine' { .. : Bar };  exact 0; exact 0; exact 0
-- -- example := by refine' { ..! : Bar }; exact 0; exact 0; exact 0

-- structure rflFoo where
--   x  : Nat
--   y  : Nat
--   xy : x = y := by rfl

-- example := by refine { ?.. : rflFoo }; (case x | y => exact 0); case xy => rfl
-- example := by refine { ?..! : rflFoo }; (case x | y => exact 0); case xy => rfl

-- structure autoFoo where
--   x  : Nat := 0
--   y  : Nat := 0
--   xy : x = y := by rfl

-- example := { ?.. : autoFoo }
-- example := by refine { ?..! : autoFoo }; (case x | y => exact 0); case xy => rfl

-- def f : Foo → Nat := fun _ => 0
-- def ff : Foo → Foo → Unit := fun _ _ => ()
-- def ffb : Foo → Bar → Unit := fun _ _ => ()
-- def ffa : Foo → autoFoo → Unit := fun _ _ => ()

-- example := by refine { x := f { ?.. }, ?.. : Foo }; case y | y_1 => exact 0
-- example := by refine { x := f { ?..x }, ?.. : Foo }; case x.y | y => exact 0
-- example := by refine { x := f { ?.. }, ?..x : Foo }; case y | x.y => exact 0
-- example := by refine { x := f { ?..x }, ?..x : Foo }; case x.y | x.y_1 => exact 0

-- example := by refine ff { ?.. } { ?.. }; case y | y_1 => exact 0
-- example := by refine ff { ?..! } { ?.. }; case x | y | y_1 => exact 0
-- example := by refine ffb { ?..! } { ?..! }; case x | y | x_1 | y_1 | z_1 => exact 0
-- example := by refine ffa { ?..! } { ?..! }; (case x | y | x_1 | y_1 => exact 0); rfl

-- structure Foo' where
--   x : Nat

-- structure dFoo' where
--   x : Nat := 0

-- def ff' : Foo → Foo' → Unit := fun _ _ => ()
-- def fdf' : Foo → dFoo' → Unit := fun _ _ => ()

-- example := by refine ff' { ?.. } { ?.. }; case y | x_1 => exact 0
-- example := by refine fdf' { ?.. } { ?.. }; case y => exact 0

-- structure Fooα (α : Type) where
--   x : α

-- example := by refine { ?.. : Fooα Nat}; case x => exact 0

-- structure Fooαi where
--   {α : Type}
--   x : α

-- example := by refine { ?.. : Fooαi }; (case α => exact Nat); case x => exact 0

-- /- haveFieldProj tests (subject to be moved)-/
-- section haveFieldProj

-- structure Foo'' where
--   x : Bool
--   y : Nat

-- def foo'': Foo'' := { x := true, y := 0 }

-- example := by
--   refine { ?.. : Foo''};
--   haveFieldProj;
--   case x => exact x.proj foo'';
--   case y => exact 0
-- example := by
--   refine { ?.. : Foo''};
--   haveFieldProj as a;
--   case x => exact a foo'';
--   case y => exact 0
-- example := by
--   refine { ?.. : Foo''};
--   haveFieldProj y;
--   case x => exact 0 == y.proj foo'';
--   case y => exact 0
-- example := by
--   refine { ?.. : Foo''};
--   haveFieldProj y as a;
--   case x => exact 0 == a foo'';
--   case y => exact 0

-- end haveFieldProj