Related questions

Subclass test without regard to type argument

2022-01-25 08:22 CarbonFlambe imported from Stackoverflow

If you run:

type Car<'T> () = class end
type Mercedes () =
    inherit Car<int> ()
let merc = Mercedes ()

and then run each of the following lines, you get the indicated results:

merc :? Mercedes        // true
box merc :? Mercedes    // true
merc :? Car<int>        // error FS0193: types not compatible
box merc :? Car<int>    // true
merc :? Car<_>          // error FS0193: types not compatible
box merc :? Car<_>      // false
  1. See the first four cases. Why do you need to box merc for the test against Car<int>, but not for the test against Mercedes?
  2. In the last two cases I'm trying to find something that'll return true because merc is a Car, without regard to the type argument. Is there such a thing?

2 answers

  • answered 2022-01-25 10:11 Tomas Petricek

    To answer your second question, there is no built-in operator for testing whether a value inherits from a class regardless of a type argument. You can check this using reflection by getting the base type of Mercedes and comparing its generic type definition with the generic type definition of Car<_>:

    merc.GetType().BaseType.GetGenericTypeDefinition() = typedefof<Car<_>>

    In practice, it may be much easier to introduce a non-generic base class though:

    type Car() = class end
type Car<'T> () = 
    inherit Car()
type Mercedes () =
    inherit Car<int> ()

let merc = Mercedes ()
box merc :? Car

    To answer your first question, I think the compiler is giving you a hint that the operation is not useful because it will always succeed - so there is no point checking this using :?.

    If you instead have a value that has a static type of Car<int> and you want to check whether it is Mercedes, this is alowed, because that is an interesting question to ask:

    Car<int>() :? Mercedes

    But checking Car<obj>() :? Mercedes is not allowed, because this is statically known to be false.

  • answered 2022-01-26 06:34 Romain Deneau

    To answer your first question:

    Why do you need to box merc for the test against Car<int>, but not for the test against Mercedes?

    From the docs, the type test operator :?

    Returns true if the value matches the specified type (including if it is a subtype); otherwise, returns false

    Line 4 box merc :? Car<int> succeeds because box merc rises the type in the hierarchy up to object, the highest type.

    Line 3 merc :? Car<int> should have return false because Mercedes > Car<int>. Instead, it's not compiling which is a behavior not documented but also not surprising for me as we always know that it cannot be true. Notice that it could have been just a warning, like in C# when we writes if (true) ....

    But it's surprising why this behavior is not applied for line 1 merc :? Mercedes. It should fail to compile for the same reason of "obviousness". Instead, it's just a warning FS0067: This type test or cast of a base class into a derived class will always succeed 🤔

    👉 Conclusion: the type test operator is really designed just as a downcast test operator. Using it in other cases like to check upcast can be misleading (at compile time) but still safe at runtime.

How many English words
do you know?
Test your English vocabulary size, and measure
how many words do you know
Online Test
Powered by Examplum

See also questions close to this topic

  • Are composition and inheritance's semantic really "HAS-A" and "IS-A"?

    Wherever you go to learn OOP (like here, here, at university and so on), I'm being taught that inheritance is a "is-a" relationship and composition is a "has-a" relationship. I used to always use this reasonning when doing OOP. But then you start seeing something called "using composition over inheritance" or even that only using "is-a" semantic all the time for inheritance is wrong.

    I don't know if I poorly understand those two OOP concepts or if it's simplified for new developpers because you can think and use those this way, in many cases.

    So my questions is:

    • If we say composition's semantic is "has-a", then why can we replace inheritance over composition which all of a sudden seems to break the "has-a" relationship. I can easily see that a "Manager IS A Person", but not that "A Manager HAS A Person".

    Is there some OOP concepts I maybe missed and that's why i'm not getting it?

  • In Python how can I overwrite the class attribute of an inherited class, where that attribute is itself an instance of a model?

    As in the title, I have a base class ListView, with a Serializer attribute that needs overwriting. For each of my django models I create a child ListView class and a Serializer. So for example for the django model Event we have a corresponding view class EventListView(ListView), and we have a corresponding Serializer class EventSerializer(Serializer).

    The Serializer child class is specified within the ListViewClass, as in my code below. Is it possible to have the serializer overwritten automatically based on the value supplied to model, and how may I mark model and Serializer as attributes that are to be overwritten and therefore do not need values specified in the base class?

    class EventSerializer(serializers.ModelSerializer):
    class Meta:
        model = Event
        fields = '__all__'

class ListView(APIView):
    model = <Model to be overwritten>        # Event is set as the default.
    Serializer = <Model Serializer to be overwritten>
    
    queryset = model.objects.all()

    def get(self,request):    
        # !!! Get filter conditions from request
        queryset = ListView.queryset.filter()    # !!! Filter conditions
        serializer = ListView.Serializer(queryset,many=True)
        return Response(serializer.data)

    def post(self,request):
        data = JSONParser.parse(request)
        serializer = ListView.Serializer(data = data)
        if serializer.is_valid():
            return Response(serializer.data, status = 201)
        else:
            return Response(serializer.errors, status = 400)


class EventListView(ListView):
    model = Event
  • Object() vs. Function()

    It is my understanding that pretty much everything in JS is an object and that constructors are one way to make a new object. I know that data types like Array, Function, and Objects all have to use the new keyword, thereby making them objects and on the backend works like new Array(), new Function() or new Object() Please correct me if I am wrong. This is where things got confusing for me. I assigned x to an array [1, 2, 3, 4]. When I inspected x, it showed that the [[prototype]] is an Array and the constructor is the Array() object. At the end, it showed the Array() object's prototype which is Object and the constructor for the Object to be Object(). I understood everything until I typed in Object.constructor and the result was Function(). Shouldn't it be Object(), instead of Function()? If the constructor of an object is new Object(), why is it telling me that Function is the constructor? That way if I create a new object it will be instantiated like this: let x = new Function(), yes? That was not the only one. Every primitive and reference data type gave the same result. Here is the code. I was so happy when I thought I grasped this knowledge and then I somehow I broke it. Hmmm, much like coding....lol. Thanks in advance for explaining.

    let x = [1, 2, 3, 4];

undefined

x;

(4) [1, 2, 3, 4]

   0: 1

   1: 2

   2: 3

   3: 4

length: 4

  **[[Prototype]]: Array(0)**

  at: ƒ at()

  concat: ƒ concat()

  **constructor: ƒ Array()**

  copyWithin: ƒ copyWithin()

  entries: ƒ entries()

  every: ƒ every()

  ...Many other Array methods...

  **[[Prototype]]: Object**

     **constructor: ƒ Object()**

     hasOwnProperty: ƒ hasOwnProperty()

     isPrototypeOf: ƒ isPrototypeOf()

     propertyIsEnumerable: ƒ propertyIsEnumerable()

     toLocaleString: ƒ toLocaleString()

    toString: ƒ toString()

    valueOf: ƒ valueOf()

    __defineGetter__: ƒ __defineGetter__()

    __defineSetter__: ƒ __defineSetter__()

    __lookupGetter__: ƒ __lookupGetter__()

    __lookupSetter__: ƒ __lookupSetter__()

    __proto__: (...)

    get __proto__: ƒ __proto__()

    set __proto__: ƒ __proto__()

**Array.constructor;**

*ƒ Function() { [native code] }*

**Object.constructor;**

*ƒ Function() { [native code] }*

**Function.constructor;**

*ƒ Function() { [native code] }*

**String.constructor;**

*ƒ Function() { [native code] }*

**Boolean.constructor;**

*ƒ Function() { [native code] }*

**Number.constructor;**

*ƒ Function() { [native code] }*
  • Is there a way to keep type inference in union types from type guards inside a function?

    Let's say I have three types (and a union one)

    type A = {
    type: 'a'
    title: string
    description: string
}

type B = {
    type: 'b'
    title: string
}

type C = {
    type: 'c'
    description: string
}

type D = A | B | C

    I know I can get a correct type inference with the === operator

    function logger(t: D) {
    if (t.type === 'a' || t.type === 'b') console.log(t.title) // no problems here
    if (t.type === 'a' || t.type === 'c') console.log(t.description) // no problems here
}

    However, would it be possible to write an utility function:

    function matches<T extends { type: string }>(t: T, types: T['type'][]) : boolean {
    return types.includes(t.type)
}

    So I can do this without errors?

    function logger(t: D) {
    if (matches(t, ['a', 'b'])) console.log(t.title) // Property 'title' does not exist on type D
    if (matches(t, ['a', 'c'])) console.log(t.description) // Property 'description' does not exist on type D
}
  • Alternative to index signature

    I have an array of object like this:

    [
  {
    "bio": "Douglas Gerald Hurley is an American engineer, former Marine Corps pilot and former NASA astronaut. He launched into space for the third time as commander of Crew Dragon Demo-2.",
    "images": {
      "png": "./assets/crew/image-douglas-hurley.png",
      "webp": "./assets/crew/image-douglas-hurley.webp"
    },
    "name": "Douglas Hurley",
    "role": "Commander"
  },
  {
    "bio": "Mark Richard Shuttleworth is the founder and CEO of Canonical, the company behind the Linux-based Ubuntu operating system. Shuttleworth became the first South African to travel to space as a space tourist.",
    "images": {
      "png": "./assets/crew/image-mark-shuttleworth.png",
      "webp": "./assets/crew/image-mark-shuttleworth.webp"
    },
    "name": "Mark Shuttleworth",
    "role": "Mission Specialist"
  },
  {
    "bio": "Pilot on the first operational flight of the SpaceX Crew Dragon to the International Space Station. Glover is a commander in the U.S. Navy where he pilots an F/A-18.He was a crew member of Expedition 64, and served as a station systems flight engineer.",
    "images": {
      "png": "./assets/crew/image-victor-glover.png",
      "webp": "./assets/crew/image-victor-glover.webp"
    },
    "name": "Victor Glover",
    "role": "Pilot"
  },
  {
    "bio": "Anousheh Ansari is an Iranian American engineer and co-founder of Prodea Systems. Ansari was the fourth self-funded space tourist, the first self-funded woman to fly to the ISS, and the first Iranian in space.",
    "images": {
      "png": "./assets/crew/image-anousheh-ansari.png",
      "webp": "./assets/crew/image-anousheh-ansari.webp"
    },
    "name": "Anousheh Ansari",
    "role": "Flight Engineer"
  }
]

    I typed that with index signature:

        export type PlanetInfo = {
      [key: string]: string;
    }[];

    but of course there are also the key "images" that are objects, I resolve that behaviour with:

        export type PlanetInfo = {
          [key: string]: any;
        }[];

    but I don't think the use of 'any' is correct. Is there a better way?

  • how to make an iterable type in type script that has a key value pair

    I am using type script and I want to make a type that represents an object like this the keys generated are genrated dynamically how do I do that

    {  dog:true,
cat:true,
x:true
}

    currently I am just using any but I woud like a proper type

     const matches: any= {}

    i get this error when i try to use

    
 {[key: string]: boolean}

    Type 'string[] | { [key: string]: boolean; }' must have a '[Symbol.iterator]()' method that returns an iterato

    code that causes this error

    const docgetter=()=>
    const matches: { [key: string]: boolean } = {}
    const documentFieldKeys = Array.isArray(documentNames) ? documentNames : Object.keys(documentNames)
  

    return [matches, documentFieldKeys]

}



const [matches,kycKeys]=docgetter()

for(key of kycKeys)
  • Hiding a System.Random instance by returning a function

    The following code comes from Stylish F# 6: Crafting Elegant Functional Code for .NET 6 listing 9-13:

    let randomByte =
    let r = System.Random()
    fun () ->
        r.Next(0, 255) |> byte
// E.g. A3-52-31-D2-90-E6-6F-45-1C-3F-F2-9B-7F-58-34-44-
for _ in 0..15 do
    printf "%X-" (randomByte())
printfn ""

    The author states, "Although we call randomByte() multiple times, only one System.Random() instance is created."

    I understand randomByte returns a function that does not create a System.Random() instance, but it seems to me multiple System.Random() instances would be created each time through the for-do-loop anyway.

    I would appreciate an explanation of how multiple instances of System.Random() are not created in this case.

  • How to approach writing a WPF Custom Control in F#?

    I am trying to understand how a wpf custom control could be written in F#.

    As an example, I have the following C# code for a drag and drop on a canvas (in C#). It inherits from ListBox. I'm not looking for anybody to rewrite this. But I'm at a loss as to how it would be implemented in Elmish.wpf since there is no xaml to deal with. (I believe a Custom Control does not have a XAML interface).

    using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Stargate.XI.Client.Views.CustomControls
{
    public delegate void DropCompletedEventHandler(object sender, DropCompletedEventArgs e);


    // To add a custom DropCompletedEvent to an ItemsControl, I would either have to have an attached property, as in
    // https://stackoverflow.com/questions/15134514/attached-behavior-handling-an-attached-event-in-wpf 
    // or subclass an ItemsControl as below. Creating a simple custom control, like here, seems cleaner.
    // Note: ItemsControl can't select items, only present collections. Only a Selector or one of it's descendants can select items
    //       Hence, only the ListBox or its derivative,ListView, have Selector's.
    public class ChartCanvas : ListBox
    {
        public event EventHandler PlayMusicEvent;
        public event EventHandler PauseMusicEvent;
        public event EventHandler StopMusicEvent;
        public event EventHandler DisposeMusicEvent;
        public event EventHandler DisposePosterEvent;

        #region DropCompletedEvent
        // Create a custom routed event by first registering a RoutedEventID
        // This event uses the bubbling routing strategy
        public static readonly RoutedEvent DropCompletedEvent = EventManager.RegisterRoutedEvent(
            "DropCompleted", RoutingStrategy.Bubble, typeof(DropCompletedEventHandler), typeof(ChartCanvas));

        // Provide CLR accessors for the event. The RoutedEventHandler, e.g., "DropCompleted" is used in the xaml declaration for the ImageCanvas.
        public event DropCompletedEventHandler DropCompleted
        {
            add { AddHandler(DropCompletedEvent, value); }
            remove { RemoveHandler(DropCompletedEvent, value); }
        }

        // This method raises the DropCompleted event
        public void RaiseDropCompletedEvent(object datatype)
        {
            RaiseEvent(new DropCompletedEventArgs(DropCompletedEvent, datatype));
        }
        #endregion

        public ChartCanvas()
        {
            AllowDrop = true;
            DragEnter += IC_DragEnter;
            Drop += IC_Drop;
            DragOver += IC_DragOver;
            DragLeave += IC_DragLeave;
        }

        private void IC_DragLeave(object sender, DragEventArgs e)
        {
            e.Handled = true;
        }

        private void IC_DragOver(object sender, DragEventArgs e)
        {
            e.Handled = true;
        }

        private void IC_Drop(object sender, DragEventArgs e)
        {
            var data = e.Data.GetData(DataFormats.Text);
            var dragSource = e.Data.GetData("DragSource");

            RaiseDropCompletedEvent(data);
        }

        private void IC_DragEnter(object sender, DragEventArgs e)
        {
            e.Handled = true;
        }

        #region PlayMovie
        private ICommand _playMovie;
        public ICommand PlayMovieCommand
        {
            get
            {
                if (_playMovie == null)
                {
                    _playMovie = new RelayCommand(
                        p => true,
                        p => this.PlayMovie());
                }
                return _playMovie;
            }
        }

        private void PlayMovie()
        {
            PlayMusicEvent?.Invoke(this, EventArgs.Empty);
        }
        #endregion

        #region PauseMovie
        private ICommand _pauseMovie;
        public ICommand PauseMovieCommand
        {
            get
            {
                if (_pauseMovie == null)
                {
                    _pauseMovie = new RelayCommand(
                        p => true,
                        p => this.PauseMovie());
                }
                return _pauseMovie;
            }
        }

        private void PauseMovie()
        {
            PauseMusicEvent?.Invoke(this, EventArgs.Empty);
        }
        #endregion

        #region StopMovie
        private ICommand _stopMovie;
        public ICommand StopMovieCommand
        {
            get
            {
                if (_stopMovie == null)
                {
                    _stopMovie = new RelayCommand(
                        p => true,
                        p => this.StopMovie());
                }
                return _stopMovie;
            }
        }

        private void StopMovie()
        {
            StopMusicEvent?.Invoke(this, EventArgs.Empty);
        }
        #endregion

        public bool Dispose
        {
            get { return (bool)GetValue(DisposeProperty); }
            set { SetValue(DisposeProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Dispose.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty DisposeProperty =
            DependencyProperty.Register("Dispose", typeof(bool), typeof(ChartCanvas), new PropertyMetadata(false,
                (s,e) =>
                {
                    ChartCanvas chartcanvas = s as ChartCanvas;
                    chartcanvas.DisposeMusicEvent?.Invoke(chartcanvas, EventArgs.Empty);
                    chartcanvas.DisposePosterEvent?.Invoke(chartcanvas, EventArgs.Empty);
                }              
                ));

    }
}

    Any suggestions to this newbie as to how to approach this would be much appreciated.

    TIA

  • Migrating to the latest FSharp.Core generates warnings

    I've just migrated my project to use FSharp.Core 6.0.3 instead of 6.0.1. I noticed that now in my code there are warnings every time I refer to uint32 with a unit of measure. More specificaly:

    • LanguagePrimitives.UInt32WithMeasure function
    • uint32<cm> as a parameter type

    I guess it's safe to set a compile flag to ignore this warning, but I'd like to understand what has happened and why this is now considered a problem.

    The exact warning message is: FS0057: Experimental library feature, requires '--langversion:preview'. This warning can be disabled using '--nowarn:57' or '#nowarn "57"'.